42

Stampa un'onda sinusoidale continua che scorre verticalmente su un terminale. Il programma non dovrebbe terminare e dovrebbe scorrere continuamente verso il basso lungo l'onda (tranne fino a quando non viene in qualche modo interrotto). È possibile supporre che l'overflow non sia un problema (ovvero è possibile utilizzare loop infiniti con contatori incrementali o ricorsione infinita).

L'onda dovrebbe soddisfare le seguenti proprietà:

Ampiezza = 20 caratteri (ampiezza di picco)
Periodo = da 60 a 65 righe (incluso)
L'output dovrebbe consistere solo di spazi, newline e |
Dopo ogni riga di output, mettere in pausa per 50ms

Uscita campione:

L'output di cui sopra dovrebbe continuare all'infinito se non diversamente interrotto, ad esempio SIGINT o SIGKILL, o chiudere la finestra del terminale, o spegnere la macchina o il Sole ingoia la Terra, ecc.

Il codice più corto vince.

Nota. Sono a conoscenza di un problema simile su Display Scrolling Waves ma questo non è esattamente lo stesso. Nel mio problema, l'onda non deve essere fatta scorrere "sul posto", ma semplicemente emetterla su un terminale. Inoltre, questo è un problema di arte ASCII, quindi non usare Mathematica per tracciarlo.

code-golf ascii-art kolmogorov-complexity

— ace_HongKongIndependence
fonte

1

Ampiezza del picco, ampiezza picco-picco o ampiezza quadrata-radice?

— DavidC,

Ampiezza del picco.

— ace_HongKongIndipendenza

1

Va bene disegnare un'onda con solo | se senza spazi?

— Gelatina

1

Tutte le risposte non sono ancora valide. Si fermano anche per SIGKILL non solo per SIGINT.

— Max Ried

1

@Max Ried bene, lo cambierò in "dovrebbe andare avanti per sempre se non diversamente interrotto".

— ace_HongKongIndipendenza

12

APL (35)

(Sì, si adatta a 35 byte, ecco una codifica APL a 1 byte )

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

Spiegazione:

{... }1: chiama la funzione con 1 all'inizio
1○⍵×.1: abbastanza vicino per il lavoro del governo sin(⍵×π÷30). ( 1○È sin).
-21+⌈20: normalizza nell'intervallo 1..40e annulla
'|'↑⍨: prende gli ultimi Ncaratteri dalla stringa '|'(che si traduce in una stringa di spazi con un |alla fine
⎕←: display
⌈⎕DL.05: attendere 50 ms e tornare 1. ( ⎕DLrestituisce il tempo effettivamente atteso, che sarà vicino 0.05, arrotondando quel valore in su 1).
∇⍵+: aggiungi quel numero ( 1) a ⍵ed esegui di nuovo la funzione.

— marinus
fonte

2

Accidenti ... Pensavo che le funzioni trigonometriche più il ritardo ti avrebbero lasciato fuori ragazzi

— ace_HongKongIndependence

2

Eccone uno da 33 caratteri:{⎕←'|'↑⍨-⌈20×1+1○⍵⋄∇.1+⍵⊣⎕DL.05}0

— Tobia,

3

@ace LOL. Dovresti dare un'occhiata a APL, non è un linguaggio di novità. È molto vecchio ed è stato utilizzato in sistemi di grandi dimensioni per decenni. È abbastanza unico, rispetto a qualsiasi altra cosa. IMHO i simboli rendono molto più leggibile che i derivati solo ASCII (J)

— Tobia,

22

C, 74 73 70 69 67 caratteri

Soluzione a 67 caratteri con molte buone idee di @ugoren e altri:

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

Soluzione a 69 caratteri con ciclo while anziché ricorsione:

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

Avvicinamento al territorio perl. :)

— treamur
fonte

1

Questo è stato ispirato dalla risposta C di @ ace.

— treamur,

2

Penso che potresti usare al 5E4posto di 50000.

— musiphil,

2

Penso che potresti usare * .1 invece di / 10.

— Moala,

1

@musiphil, ho anche pensato di usare 5E4, ma risulta che non funziona: senza mostrare il usleep()prototipo del compilatore , dovresti lanciare esplicitamente il 5E4.

— treamur,

2

È possibile ritagliare altre due caratteri spostando l'incarico di j in printf, in questo modo: printf("%*s\n",j=21+sin(i++*.1)*20,"|"). Il tipo risultante è ancora int quindi è un argomento valido per la larghezza del campo.

— Art

12

Mathematica 121 104 80 67 64

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

sine

— DavidC
fonte

domanda dice di non usare la matematica per tracciarlo. è diverso da quello in qualche modo?

— Malachi,

13

@Malachi Sì. Questo utilizza matematica per calcolarlo, proprio come qualsiasi altra risposta. Usare la matematica per tracciare sarebbe dire alla matematica di tramare x=20*sin(pi*y/30)+20o qualcosa di simile.

— Justin,

ok ho capito cosa stai dicendo grazie per il chiarimento

— Malachia,

1

Ed ecco una versione di 58 caratteriDo[Spacer[70*Sin[n*Pi/32]+70]~Print~"|";Pause@.05,{n,18!}]

— Ajasja,

1

Im non un utente Mathematica, ma penso che si può cambiare 1 == 1a 0 < 1diminuire 1 char.

— PCC

11

Perl, 48 (68)

Versione sleep GNU: 48

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

Piattaforma trasversale: 68

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

Rimosso l'uso del modulo Time :: HiRes usando la funzione sleep della shell. Incremento abbreviato come da esempio di Ruby. Abbreviato usando $ "e $ 0 vedendo suggerimenti dal lavoro di Primo Grazie per i suggerimenti Primo.

— KevinColyer
fonte

L'ho salvato come file test.pled eseguito perl ./test.pl, tuttavia il tempo di attesa non corrisponde alle specifiche. Inoltre, l'ampiezza dell'onda è troppo piccola. (Questa ampiezza si riferisce alla lunghezza tra il picco e la posizione di equilibrio.)

— ace_HongKongIndipendenza

Immagino che se avessi modificato l'incremento da .105 a .1, avrei battuto rubino a 56 caratteri!

— KevinColyer,

@primo - il mio sonno shell fa tempi inferiori a 1 secondo ...

— KevinColyer

man sleep→ unsigned int sleep(unsigned int seconds);. Non si verificherà alcun errore, ma l'intervallo di sospensione effettivo è zero. Alcuni suggerimenti per abbreviare il tuo: cambia $din $_, quindi usa (25+20*sin)e cambia \nper una nuova riga letterale.

— primo

2

@primo man 1 sleepsu una shell bash GNU / Linux ci dice cheUnlike most implementations that require NUMBER be an integer, here NUMBER may be an arbitrary floating point number.

— ace_HongKongIndependence

11

Perl - 64 (o 60) byte

Quanto segue utilizza un comando shell specifico di Windows:

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

Quanto segue usa un comando shell specifico per GNU / Linux:

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

Entrambi a 64 byte.

Il periodo è 64.
L'ampiezza massima è esattamente 20.
La curva è perfettamente simmetrica.
Ogni periodo è identico.

Nota che questa non è esattamente un'onda sinusoidale, ma piuttosto un'interpolazione quadratica. Tracciato contro un vero peccato:

Alla granularità richiesta, questi sono visivamente indistinguibili.

Se l'estetica non è così importante, offro un'alternativa a 60 byte , con lunghezza del periodo 62, ampiezza massima di ~ 20,02 e lievi asimmetrie:

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

— Primo
fonte

Questa non è un'onda sinusoidale; sono semplicemente parabole (se leggo bene il tuo codice). (Se riesci a rappresentarlo con qualche onda sinusoidale, mi piacerebbe vedere la funzione).

— Justin,

Sine è una formula, se si replica la formula è ancora un'onda sinusoidale. e questa è probabilmente una variante di Sine in qualche modo.

— Malachi,

8

Ruby 56

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

— daniero
fonte

È consentito sostituire put con p?

— Slicedpan,

1

@Slicedpan Penso che non lo farò, dal momento che questa è una sfida per disegnare qualcosa. paggiungerà doppie virgolette intorno a ciascuna riga e modificherà il "disegno".

— daniero,

7

Befunge 98 - 103, 100

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

Saluti per un programma che lo fa, in una lingua senza capacità trigonometriche; il primo programma in effetti. La seconda riga è semplicemente dati; il carattere corrispondente al valore ascii del peccato, aggiunto a un carattere spaziale.

EDIT: ho salvato 3 caratteri non sottraendo lo spazio; la sinusoide viene tradotta 32 unità a destra (che è valida).

Befunge inoltre non ha un comando sleep o qualcosa di simile. Sarebbe bello trovare un'impronta digitale, ma non sono riuscito a trovarne uno, quindi ff*:*8*spinge 8*225**2( 405000) e kzfa un noop tante volte (beh, tante volte + 1). Sulla riga di comando di Windows con pyfunge , questo risulta essere di circa 50 millisecondi, quindi dico che sto bene. Nota: se qualcuno conosce una buona impronta digitale per questo, per favore fatemelo sapere.

L'ultima parte del codice controlla semplicemente se il contatore (per la riga di dati) ha superato i dati, in caso affermativo, il contatore viene reimpostato su 0.

Ho usato questo per generare i dati.

Serie Taylor

Sebbene questa versione sia di 105 caratteri, ho dovuto solo includerlo:

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

Stavo cercando di abbreviare il mio programma e ho deciso di guardare la serie di taylor per il coseno (il seno è più difficile da calcolare). Ho cambiato xper pi * x / 30abbinare il periodo richiesto qui, quindi moltiplicato 20per corrispondere all'ampiezza. Ho apportato alcune semplificazioni (fattori corretti per l'annullamento, senza modificare di molto il valore della funzione). Quindi l'ho implementato. Purtroppo, non si tratta di un'implementazione più breve.

:f`!4*jf2*-

controlla se i valori della serie taylor stanno diventando inaccurati (circa x = 15). Se lo sono, quindi computo la serie di Taylor per x - 30invece di x.

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

è la mia implementazione della serie taylor a x = 0, quando xè il valore nello stack.

\$\f`!4*j01-*

annulla il valore della serie taylor se la serie taylor necessitasse di una regolazione.

b2*+

rendere positiva l'onda del coseno; in caso contrario, la stampa non funzionerebbe.

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

stampa l'onda

ff*:*8*kz1+

attendere improvvisamente per 50 millisecondi, quindi incrementare x

:f3*`!3*j$e-

Se xè maggiore di 45, cambiarlo in -14 (di nuovo, regolazione errore serie Taylor).

— Justin
fonte

Questo è esattamente il tipo di risposta che non vedo l'ora, spero che tu possa

— giocarci

1

Là! Ho ridotto con successo la lunghezza del codice di -5 caratteri! E c'è ancora spazio per migliorare!

— Justin,

@Quincunx anche la mia soluzione perl non utilizza alcuna funzione di trig in integrata;)

— primo

6

Pitone, 108,93,90,89, 88

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

Ora con scorrimento infinito :)

Modifica: ok, 90. Basta?

Modifica: Modifica: no, 89.

Modifica: Modifica: Modifica: 88 grazie a boothby .

— Gabriele D'Antona
fonte

Scusa se non ho chiarito la domanda - il tuo programma non dovrebbe terminare e dovrebbe scorrere continuamente verso il basso (tranne fino a SIGINT)

— ace_HongKongIndependence

1

a=0.-> a=0ti porta all'88

— stand dal

5

PHP, 59 caratteri

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

— Alex Barrett
fonte

1

È possibile salvare alcuni byte utilizzando echo ...;al posto di fwrite(STDOUT,...);.

— primo

Questo ha senso quando si chiama dalla riga di comando comunque. 10 personaggi salvati - grazie primo.

— Alex Barrett,

1

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

— primo

Molto bella. Non modificherò la mia risposta con quelle modifiche, dovresti pubblicare le tue.

— Alex Barrett,

1

@ace deve essere salvato con una codifica ansi. ideone converte automaticamente tutto in utf-8, che si rompe. ~ƒõè solo una scorciatoia per "|\n".

— primo

4

C64 BASIC, 64 caratteri PETSCII

enter image description here

Su un PAL C64, For i=0 to 2:next icicli per ca. 0,05 secondi, quindi il tempo di ritardo viene rispettato.

— Gabriele D'Antona
fonte

3

Javascript 88 76 78 caratteri

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

Basato sul codice di Kendall Frey.

— joeytje50
fonte

Non si inizializza mai i, quindi stampa una linea retta anziché un'onda.

— gilly3,

Il mio errore ... Probabilmente ha funzionato perché avevo già eseguito la sceneggiatura di Kendall nella mia console, quindi ero già stato inizializzato per me.

— joeytje50,

3

C - 86 + 3 caratteri

Grazie Shiona e Josh per la modifica

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

~~i; main (j) {for (j = 0; j ++ <20 + sin (I / 10) * 20;.) putchar (32); puts ( "|"); usleep (50000); i ++; main () ;}~~

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

Compilato con la -lmbandiera, presumo che debba aggiungere 3 caratteri

— ace_HongKongIndependence
fonte

1

Funzionerebbe se tu fossi un int e lo dividi per 10,0 (o 9,9 per salvare un carattere?) All'interno della chiamata a sin ()? i;main(j){for(j=0;j++<20+sin(i/10.0)*20;)putchar(32);puts("|");usleep(50000);i++;main();}

— Shiona,

Puoi ridurre le dimensioni a 76 caratteri circa usando printf () per sostituire il ciclo for:printf("%*s\n",(int)(21+sin(i++/10.)*20),"|")

— treamur

1

Hmm ... Mi sentirei davvero in colpa se uso questa idea nella mia risposta, specialmente quando questa è la mia domanda ... Considereresti di pubblicare una risposta tu stesso?

— ace_HongKongIndipendenza

Ok andrà bene. Grazie. :)

— treamur,

1

È possibile radere altri due personaggi se si rimuove il j=0: i;main(j){for(;j++<21+sin(i/10.)*20;)putchar(32);puts("|");usleep(50000);i++;main(1);}. Ciò si basa sul presupposto che il programma sia chiamato con 0 argomenti.

— Josh,

3

Ti-Basic, 33 byte

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

Esistono i seguenti avvertimenti :

A causa della limitazione dello schermo di 16x8, questa onda sinusoidale ha solo un'ampiezza di 7 (il periodo di 60 è ancora mantenuto)
A causa della mancanza di un modo semplice per accedere al |carattere, !viene invece utilizzato
A causa della mancanza di un preciso timer di sistema, il ritardo non viene implementato. Tuttavia, la velocità di marcia appare approssimativamente corretta.

— Mike Clark
fonte

1

Eh, dato che TI-BASIC è conteggiato in token a uno / due byte, in realtà questo è 33 byte (non "56 caratteri"), quindi in realtà avrebbe dovuto vincere la sfida!

— MI Wright,

Tranne la cosa dell'ampiezza ...

— Lirtosiast,

Bene, sì, ma andare a byte va bene.

— MI Wright,

2

JavaScript - 88

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

Sono sicuro che qualcuno può inventare qualcosa che in realtà è intelligente.

— Kendall Frey
fonte

2

J - 103,58,57, 54

Grazie a fantastici ragazzi dell'IRC

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

Nelle parole da destra a sinistra si legge: a partire da 0 infinite volte do: sin, aggiungi 1, moltiplica per 20, piano, append 1 (così diventa array di 2 elementi), copia due byte '|' di conseguenza, stampalo, attendi 0.05s e aggiungi 0.1

Invece del ciclo infinito possiamo usare la ricorsione, risparmierebbe 2 caratteri, ma produrrà anche un errore di stack dopo un certo numero di iterazioni

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

Dov'è $:una chiamata ricorsiva.

— fruscio
fonte

Ti dispiacerebbe aggiungere una piccola spiegazione, in modo che anche le persone che non hanno familiarità con la sintassi J (come me) possano capire la tua risposta?

— ace_HongKongIndependence

E 'possibile ridurre questo a 50 caratteri per agitarsi in giro con la struttura del treno: (+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)^:_]0. La versione ricorsiva salva solo 1 carattere questa volta, $:@(+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)0sebbene sembri durare più a lungo prima di toccare il fondo.

— algoritmo

2

Haskell - 75

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

Sfortunatamente, il programma non è riuscito a mettere in pausa 50 ms senza raddoppiare il mio conteggio dei caratteri, quindi inonda la console, ma produce l'onda sinusoidale.

Ecco il codice completo con pausa (138 caratteri con newline):

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
fonte

2

La pausa era uno dei requisiti. Puoi anche pubblicare il codice con la pausa?

— Justin,

Ok, l'ho pubblicato. Vorrei che Haskell ti consentisse di mettere in pausa il codice senza importazioni.

— Zaq,

Per ampiezza intendo l'ampiezza di picco, ovvero il doppio dell'ampiezza del programma corrente. Potresti voler cambiarlo in 20+20*sin xinvece di qualificarti.

— ace_HongKongIndipendenza

Oh certo. Immagino di aver frainteso quella parte della domanda.

— Zaq,

2

Perl 6: 46 caratteri

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

Crea un intervallo pigro infinito usando 0,0.1 ... *, passaci sopra. sayritorna Bool::Trueche numera come 1 in moltiplicazione, in questo modo posso tenerlo in una singola istruzione.

— Ayiko
fonte

Vedo perché sleepe .05devo essere separato. Ma mi chiedo se lo spazio tra sayed ' 'è obbligatorio?

— Matthias,

Sì: s Fornisce l'errore "2 termini di fila" che say' 'One può usaresay(' ') ma in questo caso si tratta di 1 carattere extra ...

— Ayiko

1

@Matthias: in Perl 6, gli listops non devono prendere argomenti, avere uno spazio dopo di loro o usare la parentesi. Non è un linguaggio progettato per il golf del codice, a differenza di Perl 5 (ma contiene molte belle funzionalità integrate, quindi è utilizzabile).

— Konrad Borowski il

@xfix Grazie per la spiegazione. Mi piace la lingua, ma non l'ho ancora approfondita, perché non riesco ancora ad usarla in un progetto di lavoro. Tuttavia, ho sempre intenzione di scrivere alcuni script Perl 6. @ Ayiko, apprezzo i tuoi post su Perl 6 :-)

— Matthias,

2

_fugly Javascript - 77

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

e se lo facciamo in Firefox - 73

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

e se siamo cattivi - 67

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

— eithed
fonte

1

Scala, 92,89, 87

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

— Valar Dohaeris
fonte

(20+20*math.sin(i*.1))lo riduce di 1 carattere, supponendo che questa sia sintassi valida (non ho esperienza con Scala)

— ace_HongKongIndependence

Grazie, ma l'ho scoperto anch'io :)

— ValarDohaeris,

1

Python 3, 103

Stupide importazioni frikk'n ...

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

Piuttosto che "sleep", questa implementazione si basa sulla CPU perché Python rende più semplice ottenere un orologio CPU a virgola mobile rispetto all'orologio da parete. Questo approccio non batterà quello di Friol , ma è divertente, quindi lo lascio perdere.

— Boothby
fonte

1

C #

[152] Personaggi

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

Non ho potuto ottenere la risposta C # esistente a Esegui e non ho potuto effettuare il downgrade del voto perché non ho abbastanza reputazione

mancava un paio di { e mancava a) dopo la Dichiarazione di For Loop.

Immagino che la varianza nell'aspetto dell'onda quando viene eseguita è dovuta al modo in cui stiamo cercando di visualizzare questa onda.

se non stiamo contando lo spazio dei nomi e la dichiarazione del metodo, sarebbero [104] caratteri per la versione funzionante

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

— Malachia
fonte

L'altra risposta C # funziona su gmcs. Inizialmente non riesce a compilare, ma penso che sia perché c'è un carattere non stampabile nel codice sorgente. Dopo averlo digitato nuovamente su un file vuoto, la compilazione ha esito positivo.

— ace_HongKongIndependence

I compilatori possono essere pignoli, eh?

— Malachi,

1

VB [236] [178]

non sono sicuro di come contare le schede, ho appena preso il conteggio da Notepadd ++ prima di incollarlo qui. le newline sono obbligatorie, probabilmente perché a nessuno piace usarlo per giocare a golf.

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

— Malachia
fonte

1

C #

The Magic Line [91] Personaggi

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

Programma di lavoro di seguito. [148] Personaggi

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
fonte

Scusate se non ho chiarito la domanda: il vostro programma non dovrebbe terminare e dovrebbe scorrere continuamente verso il basso (tranne fino a SIGINT). Inoltre, aggiungi un numero di caratteri.

— ace_HongKongIndipendenza

Scusa se l'ho dimenticato. Riparato ora.

— John ClearZ,

Penso che puoi perdere "Thread.Sleep" se cambiare "float" con var :) 117 caratteri. - Mi dispiace non ho visto il tempo di attesa .. 133 caratteri ora.

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

Non riesco a compilarlo in VS2010 con Threading.Thread.Sleep(50)qualcosa di sbagliato?

— Malachi,

1

Sono stato in grado di farlo funzionare, ma ho dovuto aggiungere alcune staffe e punti e virgola e non sembra lo stesso ogni periodo

— Malachia,

1

Bash + bc (per fare i conti), 80

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

— Trauma digitale
fonte

1

TI-BASIC, 30 byte

Miglioramento delle dimensioni ridotte rispetto all'altra risposta, a scapito della precisione. Si noti che TI-Basic ha tecnicamente il | personaggio, ma è necessario trasferirlo tramite computer o utilizzare un programma di assemblaggio per accedervi.

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

— MI Wright
fonte

Woah, non ho visto quanti anni aveva questa sfida! Stavo per provare a giocare a golf di più (il che è sicuramente possibile) ma non ne vale davvero la pena ...

— MI Wright,

A proposito, .03πpuò essere .1, che è ancora nell'intervallo richiesto.

— lirtosiast,

Bella cattura, grazie! Vedi un modo in cui potrei giocare a golf il comando di output? Inoltre, dal momento che ho un CSE, ho potuto ottenere questo con la giusta ampiezza (schermo da 26 caratteri) al costo di pochi byte.

— MI Wright

No, il comando di output sembra a posto - peccato che Disp abbia bisogno di un preventivo. L'ampiezza dovrebbe essere di 20 caratteri, in realtà, rendendo il requisito di larghezza dello schermo 39. Quindi funzionerebbe solo sullo schermo del grafico, e non c'è modo di farlo.

— lirtosiast,

1

Julia - 68

Modifica: grazie a ML e asso.

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

Bene, non può competere contro APL, ma ecco il mio tentativo.

Produzione:

— CCP
fonte

1

Non conosco Julia, ma è possibile utilizzare al .05posto di 0.05in sleep?

— ace_HongKongIndipendenza

Attualmente si! Grazie

— PCC

Riducilo a 68 caratteri : i=0;while 0<1;println(" "^int(20sin(.1i)+20)*"|");i+=1;sleep(.05)end——— sin(i/10)*20è uguale a20sin(.1i)

— ML

Non conosco Julia, ma potresti usare un ciclo for iterando invece su tutti i numeri naturali?

— lirtosiast,

1

MATLAB, 81 byte

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

Ho abusato del fatto che i è sempre inizializzato in MATLAB, il che significava che avrei potuto inserire fprintfla whiledichiarazione senza inizializzare iprima. Ciò significa che il programma genera prima una riga vuota, ma penso che ciò non sia proibito nelle specifiche.

Inoltre, abusa del fatto che Matlab ignorerà la maggior parte dei caratteri di controllo ASCII, stampando uno spazio anziché NULL (anche per la prima riga vuota).

— Sanchises
fonte

"Ho abusato del fatto che sono sempre inizializzato in MATLAB, il che significava che avrei potuto inserire la fprintf nell'istruzione while senza inizializzare prima i". Davvero intelligente! +1!

— Stewie Griffin,

0

F # - 90 79 77 76

Ecco una soluzione che utilizza la ricorsione

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

Probabilmente potrebbe essere ulteriormente migliorato.

— pswg
fonte

Senza sapere nulla di F #, suppongo che Thread.Sleep si aspetti un valore in ms, quindi puoi sbarazzarti di uno degli 0 e fare Thread.Sleep 50. :)

— ValarDohaeris

@ValarDohaeris Hai ragione. Ho letto male i requisiti.

— pswg

0

Tasto di scelta automatica 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

Esegui lo script. Apre il Blocco note e stampa i personaggi. Premi Esc in qualsiasi momento per uscire.

— avi
fonte

0

Clojure, 121

Versione breve:

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

Bella versione:

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

Il periodo è 64.

Digita questo lein replo salva nel file sin.cljed lein exec sin.cljeseguilo con (richiede il plugin lein-exec).

— ctrlrsf
fonte

Stampa un'onda sinusoidale (in verticale)

APL (35)

C, 74 73 70 69 67 caratteri

Mathematica 121 104 80 67 64

Perl, 48 (68)

Perl - 64 (o 60) byte

Ruby 56

Befunge 98 - 103, 100

Serie Taylor

Pitone, 108,93,90,89, 88

PHP, 59 caratteri

C64 BASIC, 64 caratteri PETSCII

Javascript 88 76 78 caratteri

C - 86 + 3 caratteri

JavaScript - 88

J - 103,58,57, 54

Haskell - 75

Perl 6: 46 caratteri

Scala, 92,89, 87

Python 3, 103

C #

VB [236] [178]

C #

Bash + bc (per fare i conti), 80

TI-BASIC, 30 byte

Julia - 68

MATLAB, 81 byte

F # - 90 79 77 76

Tasto di scelta automatica 176