42

Imprimez une onde sinusoïdale continue défilant verticalement sur un terminal. Le programme ne doit pas se terminer et doit faire défiler la vague en continu (sauf jusqu'à ce qu'elle soit interrompue). Vous pouvez supposer que le dépassement de capacité n'est pas un problème (vous pouvez utiliser des boucles infinies avec des compteurs incrémentiels ou une récursion infinie).

La vague devrait satisfaire les propriétés suivantes:

Amplitude = 20 caractères (amplitude maximale)
Période = 60 à 65 lignes (inclus)
La sortie ne doit contenir que des espaces, une nouvelle ligne et |
Après chaque ligne de sortie, pause pendant 50ms

Exemple de sortie:

La sortie ci-dessus doit rester ininterrompue sauf interruption, par exemple SIGINT ou SIGKILL, ou la fermeture de la fenêtre du terminal, la mise hors tension de votre machine, le soleil avalant la Terre, etc.

Le code le plus court gagne.

Remarque. Je suis conscient d'un problème similaire sur Display Scrolling Waves mais ce n'est pas exactement le même. Dans mon problème, il ne faut pas faire défiler la vague "en place" - il suffit de la sortir sur un terminal. En outre, il s’agit d’un problème d’art ascii, n’utilisez donc pas Mathematica pour le représenter.

code-golf ascii-art kolmogorov-complexity

— ace_HongKongIndependence
source

1

Amplitude maximale, amplitude de pic à pic ou amplitude racine-carré?

— DavidC

Amplitude maximale.

— ace_HongKongIndependence

1

Est-ce que ça va de dessiner une vague avec juste | s et sans espaces?

— Gélatine

1

Toutes les réponses sont encore invalides. Ils s’arrêtent également pour SIGKILL et pas seulement pour SIGINT.

— Max Ried

1

@ Max Ried très bien, je vais le changer en "devrait continuer indéfiniment sauf si autrement interrompu".

— ace_HongKongIndependence

12

APL (35)

(Oui, il tient dans 35 octets, voici un codage APL à 1 octet )

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

Explication:

{... }1: appelle la fonction avec 1 au début
1○⍵×.1: assez proche pour que le gouvernement travaille sin(⍵×π÷30). ( 1○est sin).
-21+⌈20: normaliser à la plage 1..40et nier
'|'↑⍨: prend les derniers Ncaractères de la chaîne '|'(ce qui donne une chaîne d'espaces avec un |fin
⎕←: afficher
⌈⎕DL.05: attendez 50 ms et revenez 1. ( ⎕DLRetourne le temps qu'il a réellement attendu, ce qui va être proche 0.05, en arrondissant cette valeur vers le haut 1).
∇⍵+: ajoutez ce nombre ( 1) à ⍵et exécutez à nouveau la fonction.

— marinus
source

2

Darn ... Je pensais que les fonctions trigonométriques et le délai différé vous laisseraient

— tomber

2

Voici un 33 caractères:{⎕←'|'↑⍨-⌈20×1+1○⍵⋄∇.1+⍵⊣⎕DL.05}0

— Tobia

3

@ace LOL. Vous devriez vérifier APL, ce n'est pas un langage de nouveauté. Il est très vieux et est utilisé dans les grands systèmes depuis des décennies. C'est assez unique, comparé à autre chose. IMHO les symboles le rendent beaucoup plus lisible que les dérivés uniquement ASCII (J)

— Tobia

22

C 74 73 70 69 67 caractères

Solution de 67 personnages avec beaucoup de bonnes idées de @ugoren & others:

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

Solution à 69 caractères avec boucle while au lieu de récursion:

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

En approchant du territoire perl. :)

— transport
source

1

Cela a été inspiré par la propre réponse en C de @ ace.

— transamur

2

Je pense que vous pourriez utiliser 5E4au lieu de 50000.

— musiphil

2

Je pense que vous pourriez utiliser * .1 au lieu de / 10.

— Moala

1

@musiphil, j'ai aussi pensé à utiliser 5E4, mais il s'avère que cela ne fonctionne pas: sans montrer le usleep()prototype du compilateur , vous devez explicitement lancer le 5E4.

— flux le

2

Vous pouvez découper deux caractères en déplaçant l'affectation à j dans le printf, comme ceci: printf("%*s\n",j=21+sin(i++*.1)*20,"|"). Le type résultant est toujours int, il s'agit donc d'un argument de largeur de champ valide.

— 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
source

question dit de ne pas utiliser mathematica pour le tracer. est-ce différent de cela en quelque sorte?

— Malachie

13

@ Malachi Oui. Cela utilise mathematica pour le calculer, comme toute autre réponse. Utiliser mathematica pour tracer serait dire à mathematica de tracer x=20*sin(pi*y/30)+20ou quelque chose de similaire.

— Justin

ok je comprends ce que vous dites merci pour la clarification

— Malachi

1

Et voici une version 58 caractèresDo[Spacer[70*Sin[n*Pi/32]+70]~Print~"|";Pause@.05,{n,18!}]

— Ajasja

1

Je ne suis pas un utilisateur de Mathematica, mais je pense que vous pouvez changer 1 == 1à 0 < 1diminuer 1 car.

— PCC

11

Perl, 48 (68)

Version de sommeil GNU: 48

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

Plate-forme transversale: 68

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

Suppression de l'utilisation du module Time :: HiRes à l'aide de la fonction de veille du shell. Incrément raccourci selon l'exemple Ruby. Raccourci avec $ "et $ 0, voir des allusions dans le travail de Primo Merci pour ces allusions à Primo.

— KevinColyer
source

J'ai enregistré ceci en tant que fichier test.plet l' ai exécuté perl ./test.pl, mais le temps d'attente ne correspond pas à la spécification. En outre, l'amplitude de la vague est trop petite. (Cette amplitude fait référence à la longueur entre le sommet et la position d'équilibre.)

— ace_HongKongIndependence

Je suppose que si je changeais l’augmentation de .105 à .1, je battrais ruby à 56 caractères!

— KevinColyer

@primo - mon sommeil shell fait des temps inférieurs à 1 seconde ...

— KevinColyer

man sleep→ unsigned int sleep(unsigned int seconds);. Cela ne provoquera pas d'erreur, mais l'intervalle de sommeil réel est zéro. Quelques suggestions pour raccourcir le vôtre: changez $dpour $_, puis utilisez (25+20*sin)et changez le \npour un saut de ligne littéral.

— Primo

2

@primo man 1 sleepsur un shell bash GNU / Linux nous dit 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) octets

Ce qui suit utilise une commande shell spécifique à Windows:

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

Ce qui suit utilise une commande shell spécifique à GNU / Linux:

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

Les deux à 64 octets.

Période est 64.
L'amplitude maximale est exactement 20.
La courbe est parfaitement symétrique.
Chaque période est identique.

Notez que ce n'est pas exactement une onde sinusoïdale, mais plutôt une interpolation quadratique. Complot contre un péché actuel:

À la granularité requise, il est impossible de les distinguer visuellement.

Si l'esthétique n'est pas si importante, je propose une alternative de 60 octets , avec une longueur de période de 62 secondes, une amplitude maximale de ~ 20,02 et de légères asymétries:

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

— primo
source

Ce n'est pas une onde sinusoïdale; ce sont simplement des paraboles (si je lis bien votre code). (Si vous pouvez représenter cela avec une onde sinusoïdale, j'aimerais voir la fonction).

— Justin

Sine est une formule, si vous la répliquez, il s'agit toujours d'une onde sinusoïdale. et ceci est probablement une variante de Sine d'une certaine manière.

— Malachi

8

Ruby 56

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

— Daniero
source

Est-ce que le remplacement par p est autorisé?

— Slicedpan

1

@ Slicedpan Je pense que non, car il est difficile de dessiner quelque chose. pajoutera des guillemets autour de chaque ligne et modifiera le "dessin".

— daniero

7

Befunge 98 - 103 100

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

Bravo pour un programme qui le fait, dans une langue sans capacités trigonométriques; le premier programme en fait. La deuxième ligne est simplement des données; le caractère correspondant à la valeur ascii du péché, ajouté à un caractère d'espacement.

EDIT: J'ai enregistré 3 caractères en ne soustrayant pas l'espace; la sinusoïde est traduite de 32 unités à droite (ce qui est valide).

Befunge n'a pas non plus de commande de veille, ou quelque chose de similaire. Il serait agréable de trouver une empreinte digitale, mais je ne pouvais pas trouver un, alors ff*:*8*pousse 8*225**2( 405000) et kzgère un noop que plusieurs fois (bien que plusieurs fois + 1). Sur la ligne de commande Windows avec pyfunge , cela s’avère être d’environ 50 millisecondes, alors je dis que je vais bien. Remarque: si quelqu'un connaît une bonne empreinte digitale, veuillez me le faire savoir.

La dernière partie du code vérifie simplement si le compteur (pour la ligne de données) a dépassé les données. Si tel est le cas, le compteur est réinitialisé à 0.

J'ai utilisé cela pour générer les données.

Série Taylor

Bien que cette version ait 105 caractères, je devais simplement l'inclure:

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

J'essayais de raccourcir mon programme et j'ai décidé de regarder la série taylor pour le cosinus (le sinus est plus difficile à calculer). J'ai changé xpour pi * x / 30correspondre à la période demandée ici, puis multiplié par 20pour correspondre à l'amplitude. J'ai fait quelques simplifications (facteurs ajustés pour l'annulation, sans trop modifier la valeur de la fonction). Puis je l'ai implémenté. Malheureusement, la mise en œuvre n'est pas plus courte.

:f`!4*jf2*-

vérifie si les valeurs de la série taylor deviennent inexactes (environ x = 15). Si tel est le cas, je calcule la série taylor pour x - 30au lieu de x.

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

est mon implémentation de la série taylor à x = 0, où xest la valeur sur la pile.

\$\f`!4*j01-*

annule la valeur de la série taylor si la série taylor doit être ajustée.

b2*+

rendre l'onde cosinus positive; sinon, l'impression ne fonctionnerait pas.

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

imprime la vague

ff*:*8*kz1+

attente improvisée pendant 50 millisecondes, puis incrémentation x

:f3*`!3*j$e-

Si xest supérieur à 45, réglez-le sur -14 (à nouveau, réglage d'erreur en série de Taylor).

— Justin
source

C’est exactement le genre de réponse que j’attends avec impatience. J'espère que vous pourrez

— jouer au

1

Là! J'ai réussi à diminuer la longueur du code de -5 caractères! Et il y a encore place à l'amélioration!

— Justin

@Quincunx ma solution perl n'utilise pas non plus de fonctions trigonométriques intégrées;)

— primo le

6

Python, 108,93,90,89, 88

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

Maintenant avec le défilement infini :)

Edit: ok, 90. Assez?

Modifier: Modifier: non, 89.

Edit: Edit: Edit: 88 grâce à boothby .

— Gabriele D'Antona
source

Désolé si je n'ai pas précisé la question - votre programme ne devrait pas s'arrêter et devrait faire défiler la vague en continu (sauf jusqu'à SIGINT)

— ace_HongKongIndependence

1

a=0.-> a=0vous amène à 88

— boothby

5

PHP, 59 caractères

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

— Alex Barrett
source

1

Vous pouvez économiser des octets en utilisant echo ...;à la place de fwrite(STDOUT,...);.

— Primo

De toute façon, cela a du sens lorsque vous appelez depuis la ligne de commande. 10 caractères enregistrés - merci primo.

— Alex Barrett

1

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

— Primo

Très agréable. Je ne modifierai pas ma réponse avec ces modifications, vous devriez poster comme la vôtre.

— Alex Barrett

1

@ace il faut le sauvegarder avec un encodage ansi. ideone convertit automatiquement tout en utf-8, ce qui rompt. ~ƒõest juste un raccourci pour "|\n".

— Primo

4

C64 BASIC, 64 caractères PETSCII

enter image description here

Sur un PAL C64, For i=0 to 2:next i cycles d’env. 0,05 seconde, le délai est donc respecté.

— Gabriele D'Antona
source

3

Javascript 88 76 78 caractères

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

Basé sur le code de Kendall Frey.

— joeytje50
source

Vous n'initialisez jamais i, donc il imprime une ligne droite au lieu d'une onde.

— gilly3

Mon erreur ... Cela a probablement fonctionné parce que j'avais déjà exécuté le script de Kendall sur ma console, donc j'avais déjà été initialisé pour moi.

— Joeytje50

3

C - 86 + 3 caractères

Merci shiona et josh pour l'édition

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

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

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

Compilé avec le -lmdrapeau, je suppose que je dois ajouter 3 caractères

— ace_HongKongIndependence
source

1

Cela fonctionnerait-il si vous faisiez un int et que vous le divisiez par 10.0 (ou 9.9 pour sauver un caractère?) Dans l'appel à sin ()? i;main(j){for(j=0;j++<20+sin(i/10.0)*20;)putchar(32);puts("|");usleep(50000);i++;main();}

— Shiona

Vous pouvez réduire la taille à environ 76 caractères en utilisant printf () pour remplacer la boucle for:printf("%*s\n",(int)(21+sin(i++/10.)*20),"|")

— treamur

1

Hmm ... Je me sentirais vraiment coupable si j'utilisais cette idée dans ma réponse, surtout lorsqu'il s'agit de ma propre question ... Souhaitez-vous envisager de poster une réponse vous-même?

— ace_HongKongIndependence

OK je le ferai. Merci. :)

— flux le

1

Vous pouvez raser deux caractères si vous supprimez le j=0: i;main(j){for(;j++<21+sin(i/10.)*20;)putchar(32);puts("|");usleep(50000);i++;main(1);}. Cela repose sur l'hypothèse que le programme est appelé avec 0 argument.

— Josh

3

Ti-Basic, 33 octets

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

Les mises en garde suivantes existent :

En raison de la limitation d'écran de 16x8, cette onde sinusoïdale n'a qu'une amplitude de 7 (la période de 60 est toujours maintenue)
En raison de l'absence d'un moyen facile d'accéder au caractère |, !est utilisé à la place
En raison du manque de minuterie système précise, le délai n’est pas appliqué. Cependant, la vitesse d'exécution semble à peu près correcte.

— Mike Clark
source

1

Heh, puisque TI-BASIC est compté dans des jetons de un / deux octets, il s’agit en fait de 33 octets (et non de "56 caractères"), ce qui aurait donc dû permettre de relever le défi!

— MI Wright

Sauf pour l'amplitude ...

— lirtosiast

Eh bien, oui, mais aller par octets c'est bien.

— MI Wright

2

JavaScript - 88

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

Je suis sûr que quelqu'un peut proposer quelque chose d'intelligent.

— Kendall Frey
source

2

J - 103,58,57, 54

Merci à des gars géniaux d'IRC

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

En mots de droite à gauche, on lit: à partir de 0 temps infinis, faites: péché, ajoutez 1, multipliez par 20, étage, ajoutez 1 (de sorte qu'il devienne un tableau de 2 éléments), copiez deux octets '|' en conséquence, imprimez-le, attendez 0.05s et ajoutez 0.1

Au lieu de boucle infinie, nous pouvons utiliser la récursivité, cela économiserait 2 caractères, mais produirait également une erreur de pile après un certain nombre d'itérations

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

Où $:est un appel récursif.

— bruissement
source

Souhaitez-vous ajouter une petite explication, de sorte que les personnes non familiarisées avec la syntaxe J (comme moi) puissent également comprendre votre réponse?

— ace_HongKongIndependence

Il est possible de raccourcir ce 50 caractères par épiloguer au sujet de la structure du train: (+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)^:_]0. La version récursive n'enregistre que 1 caractère cette fois-ci, $:@(+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)0bien qu'elle semble durer plus longtemps avant de descendre.

— algorithmshark

2

Haskell - 75

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

Malheureusement, je ne pouvais pas obtenir une pause de 50 ms du programme sans doubler le nombre de caractères, ce qui inonde la console, mais génère une onde sinusoïdale.

Voici le code complet avec pause (138 caractères avec nouvelles lignes):

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
source

2

Faire une pause était l'une des exigences. Pouvez-vous aussi poster le code avec la pause?

— Justin

Ok, je l'ai posté. Je souhaite que Haskell vous laisse mettre en pause le code sans importer.

— Zaq

Par amplitude, j'entends l'amplitude maximale, c'est-à-dire deux fois l'amplitude de votre programme actuel. Vous voudrez peut-être le changer pour 20+20*sin xvous qualifier.

— ace_HongKongIndependence

Oh, bien sûr. Je suppose que j'ai mal interprété cette partie de la question.

— Zaq

2

Perl 6: 46 caractères

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

Créez une plage infinie de lazy en utilisant 0,0.1 ... *, boucle par dessus. sayrenvoie Bool::Truece qui représente 1 dans la multiplication, ainsi je peux le conserver dans une seule déclaration.

— Ayiko
source

Je peux voir pourquoi sleepet .05doivent être séparés. Mais je me demande si l'espace entre sayet ' 'est obligatoire?

— Matthias

Oui: s Cela donne une erreur "2 termes d'affilée" pour say' 'On peut utiliser say(' ')mais c'est 1 caractère en plus dans ce cas ...

— Ayiko

1

@Matthias: en Perl 6, les listes ne doivent pas prendre d'arguments, ne doivent pas être suivies d'un espace ou utilisent des parenthèses. Ce n'est pas un langage conçu pour le golf de code, contrairement à Perl 5 (mais il contient de nombreuses fonctionnalités intégrées, donc il est utilisable).

— Konrad Borowski

@xfix Merci pour l'explication. J'aime le langage, mais je ne l'ai pas encore étudié en profondeur, car je ne peux toujours pas l'utiliser dans un projet professionnel. Cependant, je prévois toujours d’écrire des scripts Perl 6. @ Ayiko, j'apprécie vos 6 messages Perl :-)

— Matthias

2

_fugly Javascript - 77

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

et si on le fait dans Firefox - 73

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

et si nous sommes méchants - 67

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

— déchiré
source

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
source

(20+20*math.sin(i*.1))le réduit d'un caractère, en supposant que cette syntaxe est valide (je n'ai aucune expérience de Scala)

— ace_HongKongIndependence

Merci, mais je viens de découvrir que moi-même :)

— ValarDohaeris

1

Python 3, 103

Stupid frikk'n importations ...

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

Plutôt que de "dormir", cette implémentation gâche le cpu car python facilite l'obtention d'une horloge cpu à virgule flottante par rapport à une horloge murale. Cette approche ne battra pas les friol , mais c'est amusant donc je le laisse en place.

— boothby
source

1

C #

[152] Personnages

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

Je ne pouvais pas obtenir la réponse C # existante à Run et je ne pouvais pas annuler le vote parce que je n’avais pas assez de réputation

il en manquait quelques-uns {et il en manquait un )après la déclaration de boucle For.

Je suppose que la variance dans l'apparence de la vague lorsqu'elle est exécutée est due à la façon dont nous essayons d'afficher cette vague.

si nous ne comptons pas l'espace de noms et la déclaration de méthode, il s'agirait de [104] caractères pour la version de travail

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

— Malachie
source

L'autre réponse C # fonctionne sur gmcs. La compilation échoue au début, mais je pense que c’est parce que le code source contient des caractères non imprimables. Après avoir tapé à nouveau sur un fichier vide, la compilation est réussie.

— ace_HongKongIndependence

Les compilateurs peuvent être difficiles, hein?

— Malachie

1

VB [236] [178]

je ne sais pas comment vous comptez les onglets, je viens de prendre le compte de Notepadd ++ avant de coller ici. les nouvelles lignes sont obligatoires, probablement pourquoi personne n'aime l'utiliser pour le golf de code.

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

— Malachie
source

1

C #

La ligne magique [91] Personnages

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

Programme de travail ci-dessous. [148] Caractères

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
source

Désolé si je n'ai pas précisé la question - votre programme ne devrait pas se terminer et devrait faire défiler la vague en continu (sauf jusqu'à SIGINT). Ajoutez également un nombre de caractères.

— ace_HongKongIndependence

Désolé j'ai oublié ce bit. Correction maintenant.

— John ClearZ

Je pense que vous pouvez perdre "Thread.Sleep" et changer "float" avec var :) 117 caractères. - Désolé, je n'ai pas vu le temps d'attente. 133 caractères maintenant.

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

Je n'arrive pas à le compiler dans VS2010 si Threading.Thread.Sleep(50)je fais quelque chose de mal?

— Malachi

1

Je pouvais le faire fonctionner, mais je devais ajouter des crochets et des points-virgules et cela ne se ressemblait pas à chaque période

— Malachi

1

Bash + bc (faire le calcul), 80

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

— Trauma numérique
source

1

TI-BASIC, 30 octets

Amélioration de petite taille par rapport à l’autre réponse, au prix d’une certaine précision. Notez que TI-Basic a techniquement le | caractère, mais vous devez le transférer via un ordinateur ou utiliser un programme d'assemblage pour y accéder.

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

— MI Wright
source

Woah, je n'ai pas vu quel âge avait ce défi! J'allais essayer de jouer au golf encore plus (ce qui est tout à fait possible), mais ça ne vaut vraiment pas le coup ...

— MI Wright

À propos, .03πpeut être .1, ce qui est toujours dans l'intervalle requis.

— lirtosiast

Belle prise, merci! Voyez-vous un moyen de jouer au golf avec la commande de sortie? De plus, puisque j'ai un CST, je pouvais l'amener à la bonne amplitude (écran de 26 caractères) au prix de quelques octets.

— MI Wright le

Non, la commande de sortie a l'air bien - dommage que Disp ait besoin d'un devis. En fait, l'amplitude devrait être de 20 caractères, ce qui correspond à l'exigence de largeur d'écran de 39. Cela ne fonctionnerait donc que sur l'écran graphique, et il n'y a pas de moyen court de le faire.

— lirtosiast

1

Julia - 68

Edit: merci à ML et ace.

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

Eh bien, il ne peut pas rivaliser avec APL, mais voici ma tentative.

Sortie:

— PCC
source

1

Je ne sais pas Julia, mais est - il possible d'utiliser au .05lieu de 0.05dans sleep?

— ace_HongKongIndependence

En fait, oui! Merci

— CCP

Réduisez-le à 68 caractères : i=0;while 0<1;println(" "^int(20sin(.1i)+20)*"|");i+=1;sleep(.05)end——— sin(i/10)*20est égal à20sin(.1i)

— ML

Je ne connais pas Julia, mais pourriez-vous utiliser une boucle for pour parcourir à la place tous les nombres naturels?

— lirtosiast

1

MATLAB, 81 octets

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

J'ai abusé du fait que i est toujours initialisé dans MATLAB, ce qui signifie que je pouvais le mettre fprintfdans la whiledéclaration sans l'initialiser au ipréalable. Cela signifie que le programme génère d'abord une ligne vide, mais je pense que cela n'est pas interdit dans la spécification.

De plus, cela abuse du fait que Matlab ignore la plupart des caractères de contrôle ASCII, en imprimant un espace au lieu de NULL (également pour la première ligne vide).

— Sanchises
source

"J'ai abusé du fait que je suis toujours initialisé dans MATLAB, ce qui voulait dire que je pouvais mettre le fprintf dans l'instruction while sans d'abord initialiser i." Vraiment intelligent! +1!

— Stewie Griffin

0

F # - 90 79 77 76

Voici une solution utilisant la récursivité

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

Il pourrait probablement être amélioré davantage.

— pswg
source

Sans rien connaître de F #, je suppose que Thread.Sleep attend une valeur en ms. Vous pouvez donc vous débarrasser de l'un des 0 et faire Thread.Sleep 50. :)

— ValarDohaeris

@ ValarDohaeris Vous avez raison. J'ai mal interprété les exigences.

— 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

Exécutez le script. Il ouvre le Bloc-notes et imprime les caractères. Appuyez sur Echap à tout moment pour quitter.

— Avi
source

0

Clojure, 121

Version courte:

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

Jolie version:

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

Période est 64.

Tapez ceci dans lein replou sauvegardez dans un fichier sin.cljet lancez-le avec lein exec sin.clj(nécessite le plugin lein-exec).

— ctrlrsf
source

Imprimer une onde sinusoïdale (verticalement)

APL (35)

C 74 73 70 69 67 caractères

Mathematica 121 104 80 67 64

Perl, 48 (68)

Perl - 64 (ou 60) octets

Ruby 56

Befunge 98 - 103 100

Série Taylor

Python, 108,93,90,89, 88

PHP, 59 caractères

C64 BASIC, 64 caractères PETSCII

Javascript 88 76 78 caractères

C - 86 + 3 caractères

JavaScript - 88

J - 103,58,57, 54

Haskell - 75

Perl 6: 46 caractères

Scala, 92,89, 87

Python 3, 103

C #

VB [236] [178]

C #

Bash + bc (faire le calcul), 80

TI-BASIC, 30 octets

Julia - 68

MATLAB, 81 octets

F # - 90 79 77 76

AutoHotkey 176