42

Imprima una onda sinusoidal continua desplazándose verticalmente en un terminal. El programa no debe terminar y debe desplazarse continuamente hacia abajo de la onda (excepto hasta que se interrumpa de alguna manera). Puede suponer que el desbordamiento no es un problema (es decir, puede usar bucles infinitos con contadores incrementales o recursión infinita).

La ola debe satisfacer las siguientes propiedades:

Amplitud = 20 caracteres (amplitud pico)
Período = 60 a 65 líneas (inclusive)
La salida solo debe consistir en espacios, nueva línea y |
Después de cada línea de salida, haga una pausa de 50 ms.

Salida de muestra:

La salida anterior debe continuar para siempre, a menos que se interrumpa, por ejemplo, SIGINT o SIGKILL, o cierre la ventana de terminal, o apague su máquina, o el Sol se trague la Tierra, etc.

El código más corto gana.

Nota. Soy consciente de un problema similar en Display Scrolling Waves pero esto no es exactamente lo mismo. En mi problema, la onda no se debe desplazar "en su lugar", solo se genera en un terminal. Además, este es un problema ascii-art, así que no use Mathematica para trazarlo.

code-golf ascii-art kolmogorov-complexity

— ace_HongKongIndependence
fuente

1

¿Amplitud de pico, amplitud de pico a pico o amplitud de raíz cuadrada?

— DavidC

Amplitud de pico.

— ace_HongKongIndependence

1

¿Está bien dibujar una onda con solo | sy sin espacios?

— Gelatina

1

Todas las respuestas aún no son válidas. También se detienen para SIGKILL, no solo para SIGINT.

— Max Ried el

1

@Max Ried bien, lo cambiaré a "debería continuar para siempre a menos que se interrumpa lo contrario".

— ace_HongKongIndependence

12

APL (35)

(Sí, cabe en 35 bytes, aquí hay una codificación APL de 1 byte )

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

Explicación:

{... }1: llame a la función con 1 al principio
1○⍵×.1: lo suficientemente cerca para el trabajo del gobierno sin(⍵×π÷30). ( 1○es sin)
-21+⌈20: normalizar al rango 1..40y negar
'|'↑⍨: toma los últimos Ncaracteres de la cadena '|'(lo que da como resultado una cadena de espacios con un |al final
⎕←: monitor
⌈⎕DL.05: espere 50 ms y regrese 1. ( ⎕DLdevuelve la cantidad de tiempo que realmente esperó, que estará cerca 0.05, redondeando ese valor 1).
∇⍵+: agregue ese número ( 1) ⍵y ejecute la función nuevamente.

— marinus
fuente

2

Maldición ... pensé que las funciones trigonométricas más el retraso de tiempo los dejarían afuera

— ace_HongKongIndependence

2

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

— Tobia

3

@ace LOL. Deberías revisar APL, no es un lenguaje novedoso. Es muy antiguo y ha estado en uso en grandes sistemas durante décadas. Es bastante único, en comparación con cualquier otra cosa. En mi humilde opinión, los símbolos hacen que sea mucho más legible que los derivados de ASCII solo (J)

— Tobia

22

DO, 74 73 70 69 67 caracteres

Solución de 67 personajes con muchas buenas ideas de @ugoren y otros:

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

Solución de 69 caracteres con bucle while en lugar de recursividad:

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

Acercarse a territorio perl. :)

— treamur
fuente

1

Esto fue inspirado por la propia respuesta C de @ ace.

— treamur

2

Creo que podrías usar en 5E4lugar de 50000.

— musiphil

2

Creo que podrías usar * .1 en lugar de / 10.

— moala

1

@musiphil, también pensé en usar 5E4, pero resulta que no funciona: sin mostrar el usleep()prototipo del compilador , tendrías que lanzar explícitamente el 5E4.

— treamur

2

Se puede recortar dos personajes más moviendo la asignación a j en el printf, así: printf("%*s\n",j=21+sin(i++*.1)*20,"|"). El tipo resultante sigue siendo int, por lo que es un argumento de ancho de campo válido.

— Arte el

12

Mathematica 121104 80 67 64

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

seno

— DavidC
fuente

la pregunta dice que no use Mathica para trazarlo. ¿Es esto diferente de alguna manera?

— Malaquías

13

@Malachi Sí. Esto usa Mathica para calcularlo, como cualquier otra respuesta. Usar Mathica para trazar sería decirle a Mathica que trace x=20*sin(pi*y/30)+20o algo similar.

— Justin

ok entiendo lo que dices gracias por la aclaración

— Malachi

1

Y aquí hay una versión de 58 caracteresDo[Spacer[70*Sin[n*Pi/32]+70]~Print~"|";Pause@.05,{n,18!}]

— Ajasja

1

No soy un usuario de Mathematica, pero creo que puede cambiar 1 == 1a 0 < 1para disminuir 1 char.

— CCP

11

Perl, 48 (68)

GNU versión de suspensión: 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

Se eliminó el uso del módulo Time :: HiRes mediante la función de suspensión de shell. Incremento acortado según el ejemplo de Ruby. Se acortó usando $ "y $ 0 viendo sugerencias del trabajo de Primo Gracias por sugerencias Primo.

— KevinColyer
fuente

Lo guardé como un archivo test.ply lo ejecuté perl ./test.pl, sin embargo, el tiempo de espera no coincide con la especificación. Además, la amplitud de la onda es demasiado pequeña. (Esta amplitud se refiere a la longitud entre el pico y la posición de equilibrio).

— ace_HongKongIndependence

¡Supongo que si cambiara el incremento de .105 a .1, ganaría a ruby en 56 caracteres!

— KevinColyer

@primo - mi sueño de concha hace tiempos más cortos que 1 segundo ...

— KevinColyer

man sleep→ unsigned int sleep(unsigned int seconds);. No fallará, pero el intervalo de suspensión real es cero. Algunas sugerencias para acortar la suya: cambie $da $_, y luego use (25+20*sin), y cambie \npara una nueva línea literal.

— primo

2

@primo man 1 sleepen un shell bash de GNU / Linux nos dice queUnlike most implementations that require NUMBER be an integer, here NUMBER may be an arbitrary floating point number.

— ace_HongKongIndependence

11

Perl - 64 (o 60) bytes

Lo siguiente utiliza un comando de shell específico de Windows:

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

Lo siguiente usa un comando de shell específico de GNU / Linux:

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

Ambos a 64 bytes.

El período es 64.
La amplitud máxima es exactamente 20.
La curva es perfectamente simétrica.
Cada período es idéntico.

Tenga en cuenta que esto no es exactamente una onda sinusoidal, sino más bien una interpolación cuadrática. Conspirado contra un pecado real:

A la granularidad requerida, estos son visualmente indistinguibles.

Si la estética no es tan importante, ofrezco una alternativa de 60 bytes , con una duración de período 62, una amplitud máxima de ~ 20.02 y ligeras asimetrías:

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

— primo
fuente

Esta no es una onda sinusoidal; son simplemente parábolas (si leo su código correctamente). (Si puede representar esto con alguna onda sinusoidal, me encantaría ver la función).

— Justin

El seno es una fórmula, si replica la fórmula sigue siendo una onda sinusoidal. y esta es probablemente una variante de Sine de alguna manera.

— Malaquías

8

Rubí 56

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

— daniero
fuente

¿Se permite reemplazar put con p?

— Slicedpan

1

@Slicedpan Creo que no lo haré, ya que es un desafío dibujar algo. pagregará comillas dobles alrededor de cada línea y alterará el "dibujo".

— daniero

7

Befunge 98 - 103 100

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

Saludos para un programa que hace esto, en un lenguaje sin capacidades trigonométricas; El primer programa de hecho. La segunda línea es simplemente datos; el carácter correspondiente con el valor ascii del pecado, agregado a un carácter espacial.

EDITAR: ahorré 3 caracteres al no restar el espacio; la sinusoide se traduce 32 unidades a la derecha (lo cual es válido).

Befunge tampoco tiene un comando de suspensión o algo similar. Sería bueno encontrar una huella digital, pero no pude encontrar una, así que ff*:*8*presiona 8*225**2( 405000) y kzejecuta un noop tantas veces (bueno, tantas veces + 1). En la línea de comando de Windows con pyfunge , esto resulta ser de unos 50 milisegundos, así que digo que estoy bien. Nota: si alguien conoce una buena huella digital para esto, hágamelo saber.

La última parte del código simplemente verifica si el contador (para la línea de datos) ha pasado los datos, si es así, el contador se restablece a 0.

Usé esto para generar los datos.

Serie Taylor

Aunque esta versión tiene 105 caracteres, solo tuve que incluirla:

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

Estaba tratando de acortar mi programa y decidí mirar la serie taylor para coseno (el seno es más difícil de calcular). Cambié xpara pi * x / 30coincidir con el período solicitado aquí, luego lo multipliqué por 20para coincidir con la amplitud. Hice algunas simplificaciones (factores ajustados para cancelar, sin cambiar mucho el valor de la función). Luego lo implementé. Lamentablemente, no es una implementación más corta.

:f`!4*jf2*-

comprueba si los valores de la serie taylor se están volviendo inexactos (aproximadamente x = 15). Si lo son, entonces calculo la serie taylor para en x - 30lugar de x.

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

es mi implementación de la serie taylor en x = 0, cuando xes el valor en la pila.

\$\f`!4*j01-*

niega el valor de la serie taylor si la serie taylor necesitaba un ajuste.

b2*+

hacer que la onda del coseno sea positiva; de lo contrario, la impresión no funcionaría.

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

imprime la ola

ff*:*8*kz1+

improvisada espere 50 milisegundos, luego incremente x

:f3*`!3*j$e-

Si xes mayor que 45, cámbielo a -14 (nuevamente, ajuste de error de la serie taylor).

— Justin
fuente

Este es exactamente el tipo de respuesta que yo estoy deseando que llegue, espero que se puede jugar golf abajo :)

— ace_HongKongIndependence

1

¡Allí! ¡Disminuí con éxito la longitud del código en -5 caracteres! ¡Y todavía hay margen de mejora!

— Justin

@Quincunx mi solución perl tampoco utiliza ninguna función trigonométrica incorporada;)

— primo

6

Pitón, 108,93,90,8988

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

Ahora con desplazamiento infinito :)

Editar: ok, 90. ¿Suficiente?

Editar: Editar: no, 89.

Editar: Editar: Editar: 88 gracias a boothby .

— Gabriele D'Antona
fuente

Lo siento si no he aclarado la pregunta: su programa no debe finalizar y debe desplazarse continuamente hacia abajo de la ola (excepto hasta SIGINT)

— ace_HongKongIndependence

1

a=0.-> a=0te lleva a 88

— stand

5

PHP, 59 caracteres

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

— Alex Barrett
fuente

1

Puede ahorrarse algunos bytes al usar echo ...;en lugar de fwrite(STDOUT,...);.

— primo

Eso tiene sentido cuando se llama desde la línea de comandos de todos modos. 10 caracteres guardados, gracias primo.

— Alex Barrett

1

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

— primo

Muy agradable. No editaré mi respuesta con esos cambios, debe publicarla como suya.

— Alex Barrett

1

@ace necesita ser guardado con una codificación ansi. ideone convierte automáticamente todo a utf-8, que se rompe. ~ƒões solo una abreviatura de "|\n".

— primo

4

C64 BASIC, 64 caracteres PETSCII

ingrese la descripción de la imagen aquí

En un PAL C64, For i=0 to 2:next iciclos de aprox. 0,05 segundos, por lo que se respeta el tiempo de retraso.

— Gabriele D'Antona
fuente

3

Javascript 88 76 78 caracteres

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

Basado en el código de Kendall Frey.

— joeytje50
fuente

Nunca se inicializa i, por lo que imprime una línea recta en lugar de una onda.

— gilly3

Mi error ... Probablemente funcionó porque ya había ejecutado el script de Kendall en mi consola, así que ya estaba inicializado para mí.

— joeytje50

3

C - 86 + 3 caracteres

Gracias Shiona y Josh por la edición.

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); put ("|"); usleep (50000); i ++; main () ;}~~

~~flotante i; principal (j) {para (j = 0; j ++ <20 + sin (i) * 20;) putchar (32); pone ("|"); usleep (50000); i + =. 1; principal ( );}~~

Compilado con la -lmbandera, supongo que necesito agregar 3 caracteres

— ace_HongKongIndependence
fuente

1

¿Funcionaría si hicieras un int y lo dividieras entre 10.0 (o 9.9 para guardar un carácter) dentro de la llamada a sin ()? i;main(j){for(j=0;j++<20+sin(i/10.0)*20;)putchar(32);puts("|");usleep(50000);i++;main();}

— shiona

Puede reducir el tamaño a 76 caracteres más o menos usando printf () para reemplazar el bucle for:printf("%*s\n",(int)(21+sin(i++/10.)*20),"|")

— treamur

1

Hmm ... Me sentiría realmente culpable si uso esta idea en mi respuesta, especialmente cuando esta es mi propia pregunta ... ¿Consideraría publicar una respuesta usted mismo?

— ace_HongKongIndependence

OK lo haré. Gracias. :)

— treamur

1

Puede afeitarse dos personajes más si se quita el j=0: i;main(j){for(;j++<21+sin(i/10.)*20;)putchar(32);puts("|");usleep(50000);i++;main(1);}. Esto se basa en el supuesto de que el programa se llama con 0 argumentos.

— Josh

3

Ti-Basic, 33 bytes

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

Existen las siguientes advertencias :

Debido a la limitación de pantalla de 16x8, esta onda sinusoidal solo tiene una amplitud de 7 (el período de 60 aún se mantiene)
Debido a la falta de una manera fácil de acceder al |carácter, !se utiliza en su lugar
Debido a la falta de un temporizador preciso del sistema, el retraso no se implementa. Sin embargo, la velocidad de ejecución parece aproximadamente correcta.

— Mike Clark
fuente

1

Heh, dado que TI-BASIC se cuenta en tokens de uno / dos bytes, esto es en realidad 33 bytes (no "56 caracteres"), ¡así que en realidad debería haber ganado el desafío!

— MI Wright

Excepto por lo de la amplitud ...

— lirtosiast

Bueno, sí, pero ir por bytes está bien.

— MI Wright

2

JavaScript - 88

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

Estoy seguro de que a alguien se le ocurre algo que es realmente inteligente.

— Kendall Frey
fuente

2

J - 103,58,5754

Gracias a los chicos increíbles de IRC

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

En palabras de derecha a izquierda se lee: a partir de 0 infinitas veces hacer: sin, agregar 1, multiplicar por 20, piso, agregar 1 (por lo que se convierte en una matriz de 2 elementos), copiar dos bytes '|' correspondientemente, imprímalo, espere 0.05s y agregue 0.1

En lugar de bucle infinito, podemos usar la recursión, ahorraría 2 caracteres, pero también producirá un error de pila después de cierto número de iteraciones.

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

¿Dónde $:está una llamada recursiva?

— silbido
fuente

¿Le importaría agregar una pequeña explicación para que las personas que no estén familiarizadas con la sintaxis J (como yo) también puedan entender su respuesta?

— ace_HongKongIndependence

Es posible acortar este a 50 caracteres por quejarse acerca de la estructura del tren: (+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)^:_]0. La versión de recursión solo ahorra 1 char esta vez, $:@(+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)0aunque parece durar más tiempo antes de tocar fondo.

— algorithmshark

2

Haskell - 75

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

Desafortunadamente, no pude hacer que el programa detuviera 50 ms sin duplicar mi recuento de caracteres, por lo que simplemente inunda la consola, pero produce la onda sinusoidal.

Aquí está el código completo con pausa (138 caracteres con líneas nuevas):

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
fuente

2

Pausar era uno de los requisitos. ¿También puedes publicar el código con la pausa?

— Justin

Está bien, lo publiqué. Deseo que Haskell te permita detener el código sin importar.

— Zaq

Por amplitud me refiero a la amplitud máxima, es decir, el doble de la amplitud de su programa actual. Es posible que desee cambiarlo a 20+20*sin xpara calificar.

— ace_HongKongIndependence

Oh, por supuesto. Supongo que interpreté mal esa parte de la pregunta.

— Zaq

2

Perl 6: 46 caracteres

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

Cree un rango perezoso infinito usando 0,0.1 ... *, repita sobre eso. saydevuelve Bool::Trueque se numera como 1 en la multiplicación, de esta manera puedo mantenerlo en una sola declaración.

— Ayiko
fuente

Puedo ver por qué sleepy .05tengo que estar separado. Pero me pregunto si el espacio entre sayy ' 'es obligatorio?

— Matthias

Sí: s Da el error "2 términos seguidos" para que say' 'uno pueda usar, say(' ')pero eso es 1 char extra en este caso ...

— Ayiko

1

@Matthias: en Perl 6, los listops no tienen que tomar argumentos, tener un espacio después de ellos o usar paréntesis. No es un lenguaje diseñado para el golf de código, a diferencia de Perl 5 (pero contiene muchas características agradables incorporadas, por lo que es utilizable).

— Konrad Borowski

@xfix Gracias por la explicación. Me gusta el lenguaje, pero aún no lo he examinado a fondo, porque todavía no puedo usarlo en un proyecto de trabajo. Sin embargo, siempre planeo escribir algunos scripts de Perl 6. @ Ayiko, agradezco tus publicaciones de Perl 6 :-)

— Matthias

2

Javascript _fugly- 77

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

y si lo hacemos en Firefox - 73

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

y si somos desagradables - 67

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

— eithed
fuente

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
fuente

(20+20*math.sin(i*.1))lo reduce en 1 carácter, suponiendo que esta es una sintaxis válida (no tengo experiencia con Scala)

— ace_HongKongIndependence

Gracias, pero acabo de descubrirlo yo mismo :)

— ValarDohaeris

1

Pitón 3, 103

Estúpidas importaciones 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)

En lugar de "dormir", esta implementación se muele en la CPU porque Python hace que sea más fácil obtener un reloj de CPU de punto flotante que un reloj de pared. Este enfoque no superará al de friol , pero es divertido, así que lo dejo.

— boothby
fuente

1

DO#

[152] Personajes

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

No pude obtener la respuesta existente de C # para ejecutar y no pude votar porque no tengo suficiente reputación

faltaba un par de {y faltaba un )después de la Declaración For Loop.

Me imagino que la variación en el aspecto de la ola cuando se ejecuta se debe a la forma en que estamos tratando de mostrar esta ola.

si no contamos el espacio de nombres y la declaración del método, serían [104] caracteres para la versión de trabajo

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

— Malaquías
fuente

La otra respuesta de C # funciona en gmcs. Al principio no se compila, pero creo que es porque hay un carácter no imprimible en el código fuente. Después de escribirlo nuevamente en un archivo vacío, la compilación es exitosa.

— ace_HongKongIndependence

Los compiladores pueden ser exigentes, ¿eh?

— Malaquías

1

VB [236] [178]

No estoy seguro de cómo contaría las pestañas, acabo de tomar el recuento de Notepadd ++ antes de pegar aquí. las nuevas líneas son obligatorias, probablemente por qué a nadie le gusta usarlo para golf de 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

— Malaquías
fuente

1

DO#

The Magic Line [91] Personajes

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

Programa de trabajo a continuación. [148] Personajes

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
fuente

Lo siento si no he aclarado la pregunta: su programa no debe finalizar y debe desplazarse continuamente hacia abajo de la onda (excepto hasta SIGINT). Además, agregue un recuento de caracteres.

— ace_HongKongIndependence

Lo siento, olvidé ese bit. Corregido ahora.

— John ClearZ

Creo que puede perder "Thread.Sleep" sy cambiar "float" con var :) 117 caracteres. - Lo siento, no vi el tiempo de espera ... 133 caracteres ahora.

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

No puedo hacer que se compile en VS2010 con ¿ Threading.Thread.Sleep(50)Estoy haciendo algo mal?

— Malaquías

1

Pude lograr que se ejecutara, pero tuve que agregar algunos corchetes y punto y coma y no se ve igual cada período

— Malachi

1

Bash + bc (para hacer los cálculos), 80

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

— Trauma digital
fuente

1

TI-BASIC, 30 bytes

Mejora de tamaño pequeño sobre la otra respuesta, a costa de cierta precisión. Tenga en cuenta que TI-Basic técnicamente tiene el | pero debe transferirlo a través de una computadora o usar un programa de ensamblaje para acceder a él.

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

— MI Wright
fuente

Woah, ¡no vi cuántos años tenía este desafío! Iba a intentar jugar más al golf (lo cual definitivamente es posible) pero realmente no vale la pena ...

— MI Wright

Por cierto, .03πpuede ser .1, que todavía está dentro del intervalo requerido.

— lirtosiast

Buena captura, gracias! ¿Ves alguna forma en que pueda jugar al comando de salida? Además, dado que tengo un CSE, podría obtener esto con la amplitud correcta (pantalla de 26 caracteres) a costa de unos pocos bytes.

— MI Wright

No, el comando de salida se ve bien; lástima que Disp necesite una cotización. La amplitud debe ser de 20 caracteres, en realidad, lo que hace que el ancho de pantalla sea 39. Por lo tanto, solo funcionaría en la pantalla de gráficos, y no hay una forma corta de hacerlo.

— lirtosiast

1

Julia - 68

Editar: gracias a ML y as.

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

Bueno, no puede competir contra APL, pero aquí está mi intento.

Salida:

— PCC
fuente

1

No conozco a Julia, pero ¿es posible usar en .05lugar de 0.05en sleep?

— ace_HongKongIndependence

¡Actualmente, si! Gracias

— CCP

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

— ML

No conozco a Julia, pero ¿podrías usar un ciclo for iterando sobre todos los números naturales?

— 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

Abusé del hecho de que isiempre se inicializa en MATLAB, lo que significa que podría poner el fprintfen la whiledeclaración sin inicializar iprimero. Esto significa que el programa primero genera una línea vacía, pero creo que esto no está prohibido en la especificación.

Además, abusa del hecho de que Matlab ignorará la mayoría de los caracteres de control ASCII, imprimiendo un espacio en lugar de NULL (también para la primera línea vacía).

— Sanchises
fuente

"Abusé del hecho de que siempre se inicializa en MATLAB, lo que significa que podría poner el fprintf en la instrucción while sin inicializar i primero". ¡Muy inteligente! +1!

— Stewie Griffin

0

F # - 90 79 77 76

Aquí hay una solución usando recursividad

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

Probablemente podría mejorarse aún más.

— pswg
fuente

Sin saber nada sobre F #, supongo que Thread.Sleep espera un valor en ms, por lo que puede deshacerse de uno de los 0 y hacer Thread.Sleep 50. :)

— ValarDohaeris

@ValarDohaeris Tienes razón. Leí mal los requisitos.

— 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

Ejecute el script Abre el Bloc de notas e imprime los caracteres. Presione Esc en cualquier momento para salir.

— Avi
fuente

0

Clojure, 121

Version corta:

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

Versión bonita:

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

El período es 64.

Escriba esto lein replo guarde en el archivo sin.cljy ejecútelo lein exec sin.clj(requiere el complemento lein-exec).

— ctrlrsf
fuente

Imprimir una onda sinusoidal (verticalmente)

APL (35)

DO, 74 73 70 69 67 caracteres

Mathematica 121104 80 67 64

Perl, 48 (68)

Perl - 64 (o 60) bytes

Rubí 56

Befunge 98 - 103 100

Serie Taylor

Pitón, 108,93,90,8988

PHP, 59 caracteres

C64 BASIC, 64 caracteres PETSCII

Javascript 88 76 78 caracteres

C - 86 + 3 caracteres

JavaScript - 88

J - 103,58,5754

Haskell - 75

Perl 6: 46 caracteres

Scala 92,8987

Pitón 3, 103

DO#

VB [236] [178]

DO#

Bash + bc (para hacer los cálculos), 80

TI-BASIC, 30 bytes

Julia - 68

MATLAB, 81 bytes

F # - 90 79 77 76

AutoHotkey 176