42

Imprima uma onda sinusoidal contínua rolando verticalmente em um terminal. O programa não deve terminar e deve rolar a onda continuamente para baixo (exceto até que de alguma forma seja interrompida). Você pode assumir que o estouro não é um problema (ou seja, você pode usar loops infinitos com contadores crescentes ou recursão infinita).

A onda deve satisfazer as seguintes propriedades:

Amplitude = 20 caracteres (amplitude de pico)
Período = 60 a 65 linhas (inclusive)
A saída deve consistir apenas em espaços, nova linha e |
Após cada linha de saída, faça uma pausa de 50ms

Saída de amostra:

A saída acima deve durar para sempre, a menos que seja interrompido de outra forma, por exemplo, SIGINT ou SIGKILL, ou fechar a janela do terminal, ou você desligue sua máquina, ou o Sol engula a Terra, etc.

O menor código vence.

Nota. Estou ciente de um problema semelhante no Display Scrolling Waves, mas isso não é exatamente o mesmo. No meu problema, a onda não deve ser rolada "no lugar" - basta imprimi-la em um terminal. Além disso, esse é um problema artístico, portanto, não use o Mathematica para plotá-lo.

code-golf ascii-art kolmogorov-complexity

— ace_HongKongIndependence
fonte

1

Amplitude de pico, amplitude de pico a pico ou amplitude de raiz quadrada?

— DavidC

Amplitude de pico.

— ace_HongKongIndependence 16/01

1

Tudo bem desenhar uma onda com apenas | se sem espaços?

— Gelatina

1

Todas as respostas ainda são inválidas. Eles também param para a SIGKILL e não apenas para a SIGINT.

— Max Ried

1

@ Max Ried bem, vou alterá-lo para "deve continuar para sempre, a menos que interrompido de outra forma".

— ace_HongKongIndependence

12

APL (35)

(Sim, cabe em 35 bytes, aqui está uma codificação APL de 1 byte )

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

Explicação:

{... }1: chame a função com 1 no início
1○⍵×.1: perto o suficiente para o trabalho do governo sin(⍵×π÷30). ( 1○é sin).
-21+⌈20: normalize para o intervalo 1..40e negue
'|'↑⍨: pega os últimos Ncaracteres da sequência '|'(o que resulta em uma sequência de espaços com um |no final
⎕←: exibição
⌈⎕DL.05: aguarde 50 ms e volte 1. ( ⎕DLretorna a quantidade de tempo que realmente esperou, que será próximo 0.05, arredondando esse valor para cima 1).
∇⍵+: adicione esse número ( 1) a ⍵e execute a função novamente.

— marinus
fonte

2

Droga ... Eu pensei que funções trigonométricas, mais o atraso de tempo, deixariam vocês de fora

— ace_HongKongIndependence

2

Aqui está um caractere de 33 caracteres:{⎕←'|'↑⍨-⌈20×1+1○⍵⋄∇.1+⍵⊣⎕DL.05}0

— Tobia

3

@ace LOL. Você deve verificar o APL, não é uma linguagem de novidade. É muito antigo e está em uso em grandes sistemas há décadas. É único, comparado a qualquer outra coisa. IMHO os símbolos tornam muito mais legível de que os derivativos somente ASCII (J)

— Tobia

22

C, 74 73 70 69 67 caracteres

Solução de 67 caracteres com muitas boas idéias de @ugoren e outros:

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

Solução de 69 caracteres com loop while em vez de recursão:

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

Aproximando-se do território perl. :)

— treamur
fonte

1

Isso foi inspirado na resposta C do próprio @ ace.

— treamur

2

Eu acho que você poderia usar em 5E4vez de 50000.

— Musiphil

2

Eu acho que você poderia usar * .1 em vez de / 10.

— moala

1

@musiphil, eu também pensei em usar o 5E4, mas acontece que não funciona: sem mostrar o usleep()protótipo do compilador , você precisaria lançar explicitamente o 5E4.

— treamur

2

Você pode cortar mais dois personagens movendo a atribuição para j para o printf, como este: printf("%*s\n",j=21+sin(i++*.1)*20,"|"). O tipo resultante ainda é int, portanto, é um argumento válido de largura de 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++]

seno

— DavidC
fonte

pergunta diz para não usar o mathematica para plotá-lo. isso é diferente do que isso de alguma forma?

— Malachi

13

@Malachi Sim. Isso usa o mathematica para calculá-lo, assim como qualquer outra resposta. Usar o mathematica para plotar seria dizer ao mathematica para plotar x=20*sin(pi*y/30)+20ou algo semelhante.

— Justin

ok eu tenho o que você está dizendo que você agradecer pelo esclarecimento

— Malaquias

1

E aqui está uma versão de 58 caracteresDo[Spacer[70*Sin[n*Pi/32]+70]~Print~"|";Pause@.05,{n,18!}]

— Ajasja

1

Im não um usuário Mathematica, mas eu acho que você pode mudar 1 == 1a 0 < 1diminuir 1 caractere.

— CCP

11

Perl, 48 (68)

Versão do sono GNU: 48

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

Plataforma cruzada: 68

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

Removido o uso do módulo Time :: HiRes usando a função de suspensão do shell. Incremento reduzido conforme o exemplo do Ruby. Encurtado usando $ "e $ 0, vendo dicas do trabalho de Primo Obrigado pelas dicas Primo.

— KevinColyer
fonte

Salvei isso como um arquivo test.ple executei perl ./test.pl, no entanto, o tempo de espera não corresponde à especificação. Além disso, a amplitude da onda é muito pequena. (Isto refere-se a amplitude do comprimento entre o pico e a posição de equilíbrio.)

— ace_HongKongIndependence

Eu acho que se eu alterasse o incremento de .105 para .1 eu venceria o ruby com 56 caracteres!

— precisa saber é o seguinte

@primo - minha concha sono faz fazer vezes menor do que 1 segundo ...

— KevinColyer

man sleep→ unsigned int sleep(unsigned int seconds);. Não haverá erro, mas o intervalo de suspensão real é zero. Algumas sugestões para tornar a sua mais curta: altere $dpara $_e, em seguida (25+20*sin), use e altere o \npara uma nova linha literal.

— Primo

2

O @primo man 1 sleepem um shell bash do GNU / Linux nos diz queUnlike most implementations that require NUMBER be an integer, here NUMBER may be an arbitrary floating point number.

— ace_HongKongIndependence

11

Perl - 64 (ou 60) bytes

A seguir, um comando shell específico do Windows:

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

A seguir, é utilizado um comando shell específico do GNU / Linux:

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

Ambos em 64 bytes.

O período é 64.
A amplitude máxima é exatamente 20.
A curva é perfeitamente simétrica.
Todo período é idêntico.

Observe que essa não é exatamente uma onda sinusoidal, mas uma interpolação quadrática. Traçados contra um pecado real:

Na granularidade requerida, elas são visualmente indistinguíveis.

Se a estética não é tão importante, ofereço uma alternativa de 60 bytes , com duração de período 62, amplitude máxima de ~ 20,02 e pequenas assimetrias:

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

— primo
fonte

Esta não é uma onda sinusoidal; são simplesmente parábolas (se eu leio seu código corretamente). (Se você pode representar isso com alguma onda sinusoidal, eu adoraria ver a função).

— Justin

O seno é uma fórmula, se você replicar a fórmula, ainda é uma onda sinusoidal. e esta é provavelmente uma variante do Sine de alguma forma.

— Malachi

8

Ruby 56

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

— daniero
fonte

É permitido substituir por p?

— Slicedpan

1

@ Slicedpan Acho que não vou, já que este é um desafio para desenhar algo. padicionará aspas duplas ao redor de cada linha e alterará o "desenho".

— Daniero 17/01/14

7

Befunge 98 - 103 100

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

Felicidades para um programa que faz isso, em um idioma sem capacidades trigonométricas; o primeiro programa de fato. A segunda linha é simplesmente dados; o caractere correspondente ao valor ascii do pecado, adicionado a um caractere de espaço.

Edição: eu salvei 3 caracteres, não subtraindo o espaço; o sinusóide é traduzido 32 unidades para a direita (o que é válido).

O Befunge também não possui um comando de suspensão ou algo semelhante. Seria bom encontrar uma impressão digital, mas não consegui encontrar uma, então ff*:*8*empurra 8*225**2( 405000) e kzexecuta um noop tantas vezes (bem, tantas vezes + 1). Na linha de comando do Windows com pyfunge , isso acaba sendo de cerca de 50 milissegundos, então eu digo que sou bom. Nota: se alguém souber uma boa impressão digital, informe-me.

A última parte do código simplesmente verifica se o contador (para a linha de dados) passou dos dados; se estiver, o contador é redefinido para 0.

Eu usei isso para gerar os dados.

Taylor Series

Embora esta versão tenha 105 caracteres, eu apenas precisei incluí-la:

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

Eu estava tentando encurtar meu programa e decidi olhar para a série de taylor em busca de cosseno (o seno é mais difícil de calcular). Mudei xpara pi * x / 30corresponder ao período solicitado aqui e, em seguida, multipliquei por 20para corresponder à amplitude. Fiz algumas simplificações (fatores ajustados para cancelar, sem alterar muito o valor da função). Então eu implementei. Infelizmente, não é uma implementação mais curta.

:f`!4*jf2*-

verifica se os valores da série taylor estão ficando imprecisos (sobre x = 15). Se eles são, então eu calculo a série de taylor em x - 30vez de x.

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

é minha implementação da série taylor em x = 0, quando xé o valor na pilha.

\$\f`!4*j01-*

nega o valor da série taylor se a série taylor precisar de ajuste.

b2*+

tornar a onda cosseno positiva; caso contrário, a impressão não funcionaria.

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

imprime a onda

ff*:*8*kz1+

improvisada, aguarde 50 milissegundos e depois aumente x

:f3*`!3*j$e-

Se xfor maior que 45, altere para -14 (novamente, ajuste de erro da série taylor).

— Justin
fonte

Este é exatamente o tipo de resposta que eu estou olhando para a frente, espero que você pode golfe-lo para baixo :)

— ace_HongKongIndependence

1

Lá! Reduzi com sucesso o comprimento do código em -5 caracteres! E ainda há espaço para melhorias!

— Justin

@Quincunx minha solução perl também não usa funções trigonométricas embutidas;)

— 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

Agora com rolagem infinita :)

Edit: ok, 90. Chega?

Editar: Editar: não, 89.

Edit: Edit: Edit: 88 graças a boothby .

— Gabriele D'Antona
fonte

Desculpe se eu não ter feito a pergunta clara - o programa não deve terminar e deve continuamente rolar a onda (exceto até SIGINT)

— ace_HongKongIndependence

1

a=0.-> a=0você fica a 88

— Boothby

5

PHP, 59 caracteres

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

— Alex Barrett
fonte

1

Você pode economizar alguns bytes usando echo ...;no lugar de fwrite(STDOUT,...);.

— primo

Isso faz sentido ao chamar da linha de comando de qualquer maneira. 10 caracteres salvos - obrigado primo.

— Alex Barrett

1

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

— primo

Muito agradável. Não vou editar minha resposta com essas alterações, você deve postar como sua.

— Alex Barrett

1

@ace ele precisa ser salvo com uma codificação ansi. O ideone converte automaticamente tudo em utf-8, que quebra. ~ƒõé apenas uma abreviação de "|\n".

— Primo

4

C64 BASIC, 64 PETSCII chars

insira a descrição da imagem aqui

Em um PAL C64, For i=0 to 2:next ialterna por aprox. 0,05 segundos, para que o tempo de atraso seja respeitado.

— Gabriele D'Antona
fonte

3

Javascript 88 76 78 caracteres

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

Baseado no código de Kendall Frey.

— joeytje50
fonte

Você nunca inicializa i, por isso imprime uma linha reta em vez de uma onda.

— precisa saber é o seguinte

Meu erro ... Provavelmente funcionou porque eu já tinha executado o script do Kendall no meu console, então eu já fui inicializado.

— joeytje50

3

C - 86 + 3 caracteres

Obrigado shiona e Josh pela edição

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

~~i; main (j) {para (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); puts ("|"); usleep (50000); i + = 0,1; main ( );}~~

Compilado com a -lmbandeira, suponho que preciso adicionar 3 caracteres

— ace_HongKongIndependence
fonte

1

Funcionaria se você fizesse um int e apenas o dividisse por 10,0 (ou 9,9 para salvar um caractere?) Na chamada para sin ()? i;main(j){for(j=0;j++<20+sin(i/10.0)*20;)putchar(32);puts("|");usleep(50000);i++;main();}

— shiona

Você pode diminuir o tamanho para 76 caracteres usando printf () para substituir o loop for:printf("%*s\n",(int)(21+sin(i++/10.)*20),"|")

— treamur

1

Hmm ... eu me sentiria realmente culpado se usasse essa idéia na minha resposta, especialmente quando essa for minha própria pergunta ... Você consideraria postar uma resposta você mesmo?

— ace_HongKongIndependence

Ok, vai fazer. Obrigado. :)

— treamur

1

Você pode raspar mais dois personagens se remover o j=0: i;main(j){for(;j++<21+sin(i/10.)*20;)putchar(32);puts("|");usleep(50000);i++;main(1);}. Isso se baseia na suposição de que o programa é chamado com 0 argumentos.

— Josh Josh

3

Ti-Basic, 33 bytes

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

Existem as seguintes advertências :

Devido à limitação da tela de 16x8, essa onda senoidal tem apenas uma amplitude de 7 (o período de 60 ainda é mantido)
Devido à falta de uma maneira fácil de acessar o |char, !é usado
Devido à falta de um cronômetro preciso do sistema, o atraso não é implementado. No entanto, a velocidade de execução parece aproximadamente correta.

— Mike Clark
fonte

1

Heh, como o TI-BASIC é contado em tokens de um / dois bytes, na verdade são 33 bytes (não "56 caracteres"), portanto, ele deveria ter vencido o desafio!

— MI Wright

Exceto para a coisa amplitude ...

— lirtosiast

Bem, sim, mas passando por bytes está tudo bem.

— MI Wright

2

JavaScript - 88

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

Tenho certeza de que alguém pode inventar algo realmente inteligente.

— Kendall Frey
fonte

2

J - 103,58,5754

Graças a caras incríveis do IRC

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

Em palavras da direita para a esquerda, lê-se: a partir de 0 infinitas vezes: sin, adicione 1, multiplique por 20, floor, acrescente 1 (para que se torne uma matriz de 2 elementos), copie dois bytes '|' correspondentemente, imprima, aguarde 0,05s e adicione 0,1

Em vez de loop infinito, podemos usar a recursão, ele salvaria 2 caracteres, mas também produzirá um erro de pilha após algumas iterações

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

Onde $:é uma chamada recursiva.

— swish
fonte

Você se importaria de adicionar uma pequena explicação, para que pessoas não familiarizadas com a sintaxe J (como eu) também possam entender sua resposta?

— ace_HongKongIndependence

É possível encurtar este a 50 caracteres por agitação sobre a estrutura do comboio: (+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)^:_]0. A versão de recursão salva apenas 1 caractere dessa vez, $:@(+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)0embora pareça durar mais tempo antes de chegar ao fundo do poço.

— algorithmshark

2

Haskell - 75

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

Infelizmente, não consegui fazer o programa pausar 50 ms sem dobrar minha contagem de caracteres, por isso apenas inunda o console, mas produz a onda senoidal.

Aqui está o código completo com a pausa (138 caracteres com novas linhas):

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

A pausa foi um dos requisitos. Você também pode postar o código com a pausa?

— Justin

Ok, eu postei. Desejo que Haskell permita que você pause o código sem importar.

— Zaq

Por amplitude, quero dizer a amplitude de pico, ou seja, o dobro da amplitude do seu programa atual. Você pode alterar 20+20*sin xpara qualificar.

— ace_HongKongIndependence

Ah com certeza. Acho que interpretei mal essa parte da pergunta.

— Zaq 18/01/14

2

Caracteres do Perl 6: 46

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

Crie um intervalo preguiçoso infinito usando 0,0.1 ... *, faça um loop sobre isso. sayretorna Bool::Trueque numera como 1 em multiplicação, desta forma eu posso mantê-lo em uma única instrução.

— Ayiko
fonte

Eu posso ver o porquê sleepe .05tenho que ser separado. Mas eu me pergunto se o espaço entre saye ' 'é obrigatório?

— Matthias

Sim: s say' 'say(' ')

— Emite

1

@ Matthias: No Perl 6, os listops não precisam aceitar argumentos, ter um espaço após eles ou usar parênteses. Não é uma linguagem projetada para código de golfe, diferente do Perl 5 (mas contém muitos recursos internos agradáveis, por isso é utilizável).

— precisa saber é o seguinte

@xfix Obrigado pela explicação. Eu gosto do idioma, mas ainda não o examinei completamente, porque ainda não posso usá-lo em um projeto de trabalho. No entanto, eu sempre planejo escrever alguns scripts Perl 6. @ Ayiko, eu aprecio seus Perl 6 posts :-)

— Matthias

2

_fugly Javascript - 77

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

e se fizermos isso no Firefox - 73

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

e se somos desagradáveis - 67

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

— eithed
fonte

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
fonte

(20+20*math.sin(i*.1))reduz em 1 char, assumindo que este é válido sintaxe (não tenho experiência com Scala)

— ace_HongKongIndependence

Obrigado, mas acabo de descobrir que eu mesmo :)

— ValarDohaeris

1

Python 3, 103

Imitações estúpidas de 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)

Em vez de "dormir", essa implementação funciona na CPU, porque o Python facilita a obtenção de um clock da CPU de ponto flutuante em vez do relógio de parede. Essa abordagem não supera o friol , mas é divertido, então eu estou deixando para lá.

— boothby
fonte

1

C #

[152] Personagens

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

Não consegui obter a resposta C # existente para Executar e não pude reduzir a votação porque não tenho reputação suficiente

faltavam algumas {e )depois da declaração For Loop.

Eu acho que a variação na aparência da onda quando ela é executada é por causa da maneira como estamos tentando exibir essa onda.

se não estivermos contando o espaço para nome e a declaração do método, seriam [104] caracteres para a versão de trabalho

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

— Malaquias
fonte

A outra resposta C # funciona em gmcs. Ele falha na compilação no início, mas acho que é porque existe algum caractere não imprimível no código-fonte. Depois de digitar novamente em um arquivo vazio, a compilação foi bem-sucedida.

— ace_HongKongIndependence

Compiladores podem ser exigentes, não é?

— Malachi

1

VB [236] [178]

Não tenho certeza de como você contaria as guias, peguei a contagem do Notepadd ++ antes de colar aqui. as novas linhas são obrigatórias, provavelmente por que ninguém gosta de usá-las no golfe com código.

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

— Malaquias
fonte

1

C #

A Linha Mágica [91] Personagens

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

Programa de trabalho abaixo. [148] Personagens

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

Desculpe se eu não esclareci a questão - seu programa não deve terminar e deve rolar a onda continuamente para baixo (exceto até SIGINT). Além disso, adicione uma contagem de caracteres.

— ace_HongKongIndependence

Desculpe esqueci esse pedaço. Corrigido agora.

— precisa saber é o seguinte

Eu acho que você pode perder "Thread.Sleep" se mudar "float" com var :) 117 caracteres. - Desculpe, não vi o tempo de espera .. 133 caracteres agora.

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

Não consigo compilar no VS2010, Threading.Thread.Sleep(50)estou fazendo algo errado?

— Malachi

1

Eu era capaz de fazê-lo correr, mas eu tive que adicionar alguns suportes e Semi-e-vírgula e não têm a mesma aparência cada período

— Malaquias

1

Bash + bc (para fazer as contas), 80

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

— Trauma Digital
fonte

1

TI-BASIC, 30 bytes

Melhoria de tamanho pequeno em relação à outra resposta, ao custo de alguma precisão. Observe que a TI-Basic possui tecnicamente o | caractere, mas você deve transferi-lo via computador ou usar um programa de montagem para acessá-lo.

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

— MI Wright
fonte

Woah, não viu quantos anos esse desafio tinha! Estava indo para tentar golf isso mais (que é definitivamente possível), mas não é realmente vale a pena ...

— MI Wright

By the way, .03πpode ser .1, que ainda está dentro do intervalo necessário.

— lirtosiast

Boa captura, obrigado! Você vê alguma maneira de eu jogar o comando de saída? Além disso, como eu tenho um CSE, eu poderia obtê-lo na amplitude correta (tela de 26 caracteres) ao custo de alguns bytes.

— MI Wright

Não, o comando de saída parece bom - pena que o Disp precise de uma cotação. A amplitude deve ser de 20 caracteres, na verdade, tornando o requisito de largura de tela 39. Portanto, funcionaria apenas na tela de gráfico, e não há uma maneira curta de fazer isso.

— lirtosiast

1

Julia - 68

Edit: graças a ML e ás.

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

Bem, ele não pode competir contra APL, mas aqui está minha tentativa.

Saída:

— PCC
fonte

1

Eu não sei Julia, mas é possível usar .05, em vez de 0.05nos sleep?

— ace_HongKongIndependence

Na verdade sim! Obrigado

— CCP

Reduza para 68 caracteres : i=0;while 0<1;println(" "^int(20sin(.1i)+20)*"|");i+=1;sleep(.05)end——— sin(i/10)*20é igual a20sin(.1i)

— ML

Eu não conheço Julia, mas você poderia usar um loop for repetindo todos os números naturais?

— 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

Eu abusei do fato de isempre ser inicializado no MATLAB, o que significava que eu poderia colocar o fprintfna whiledeclaração sem inicializar iprimeiro. Isso significa que o programa gera primeiro uma linha vazia, mas acho que isso não é proibido nas especificações.

Além disso, abusa do fato de o Matlab ignorar a maioria dos caracteres de controle ASCII, imprimindo um espaço em vez de NULL (também para a primeira linha vazia).

— Sanchises
fonte

"Eu abusei do fato de eu sempre ser inicializado no MATLAB, o que significava que eu poderia colocar o fprintf na instrução while sem inicializá-lo primeiro". Realmente inteligente! +1!

— Stewie Griffin

0

F # - 90 79 77 76

Aqui está uma solução usando recursão

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

Provavelmente poderia ser melhorado ainda mais.

— pswg
fonte

Sem saber nada sobre F #, eu estou supondo que Thread.Sleep espera um valor em ms, assim você pode se livrar de um dos 0 e fazer Thread.Sleep 50. :)

— ValarDohaeris

@ValarDohaeris Você está certo. Eu interpretei mal os requisitos.

— Pwg

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

Execute o script. Abre o bloco de notas e imprime os caracteres. Pressione Esc a qualquer momento para sair.

— Avi
fonte

0

Clojure, 121

Versão curta:

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

Versão bonita:

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

O período é 64.

Digite isso lein replou salve no arquivo sin.clje execute com lein exec sin.clj(requer o plugin lein-exec).

— ctrlrsf
fonte

Imprimir uma onda sinusoidal (verticalmente)

APL (35)

C, 74 73 70 69 67 caracteres

Mathematica 121 104 80 67 64

Perl, 48 (68)

Perl - 64 (ou 60) bytes

Ruby 56

Befunge 98 - 103 100

Taylor Series

Python, 108,93,90,8988

PHP, 59 caracteres

C64 BASIC, 64 PETSCII chars

Javascript 88 76 78 caracteres

C - 86 + 3 caracteres

JavaScript - 88

J - 103,58,5754

Haskell - 75

Caracteres do Perl 6: 46

Scala, 92,8987

Python 3, 103

C #

VB [236] [178]

C #

Bash + bc (para fazer as contas), 80

TI-BASIC, 30 bytes

Julia - 68

MATLAB, 81 bytes

F # - 90 79 77 76

AutoHotkey 176