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~"|";[email protected]; 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~"|";[email protected],{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)

Respostas:

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