Objectif: écrire un programme ou une fonction qui imprime une chaîne d'entrée sous une forme sinusoïdale.
La sinusoïde ASCII
Voici une période de la sinusoïde:
.......
... ...
.. ..
. .
. .
. .
. . .
. .
. .
. .
.. ..
... ...
.......
Notez qu'il y a exactement un point sur chaque colonne.
- Chaque caractère de la chaîne d'entrée remplacera un point dans la forme ci-dessus, de gauche à droite.
- Les espaces dans l'entrée doivent être sortis comme des caractères normaux, à la place d'un point.
- Le caractère de départ correspond au point le plus à gauche de la figure ci-dessus.
- Ce n'est qu'une période, les entrées peuvent être plus longues que le nombre de points ci-dessus.
Contribution
- Les entrées sont des chaînes ASCII qui contiennent uniquement des caractères entre ASCII décimal 32 (espace) et ASCII décimal 126 (Tilde ~).
- Les entrées seront toujours une seule ligne (pas de sauts de ligne).
- Les entrées peuvent être prises via STDIN, les paramètres de fonction, les arguments de ligne de commande ou quelque chose de similaire.
Sortie
- La sortie doit être imprimée exactement comme dans les cas de test donnés.
- Les espaces de fin sur les lignes sont autorisés tant que la longueur de la ligne avec ces espaces de fin ne dépasse pas la longueur de la ligne la plus longue (celle qui contient le dernier caractère).
- Aucune ligne avant / arrière autorisée.
Cas de test
- Contribution:
.................................................
Sortie:
.......
... ...
.. ..
. .
. .
. .
. . .
. .
. .
. .
.. ..
... ...
.......
- Contribution:
Programming Puzzles & Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It's 100% free, no registration required.
Sortie:
ng Puzz ion and siasts stratio
mmi les est an thu and egi n r
ra & qu sw en c r eq
g e o o u
o C a r e d n i
r o l e r
P d s s z , e
e i i z g e d
t u o e .
G e e p l r
ol ng f g fe f
f S cha or min rs. 00%
tack Ex program It's 1
- Contribution:
Short text.
Sortie:
t.
tex
t
r
o
h
S
- Contribution:
The quick brown fox jumps over the lazy dog
Sortie:
brown
ick fox
qu j
u
e m
h p
T s
o
v
er
th dog
e lazy
Notation
C'est le code-golf , donc le programme ou la fonction la plus courte en octets l'emporte.
sinfonction pour la reproduire mais les positions sont un peu décalées.)Réponses:
Pyth, 59 octets (57 caractères)
Manifestation.
Une table de recherche binaire est codée à l'intérieur
, qui a la valeur 3912. Elle est convertie en binaire, donnant[1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0]. Ceci est traité comme les différences entre des hauteurs consécutives. En ajoutant un 6, en formant tous les préfixes et en les mappant chacun à sa somme, le premier quart de l'onde est généré.sM._+6jC\2s'évalue[6, 7, 8, 9, 10, 10, 11, 11, 11, 12, 12, 12, 12]comme décrit ci-dessus. Ensuite, le code concatène à l'envers de cette chaîne pour former la première moitié de l'onde, puis la soustrait de 12 pour donner l'onde entière.Ensuite, nous formons des lignes de chaque caractère saisi suivies de 12 espaces. Cette ligne est tournée vers la droite par le paramètre de hauteur de vague correspondant à cet emplacement, puis les lignes sont transposées et jointes sur des nouvelles lignes.
Ensuite, nous supprimons les lignes vides de début et de fin. Cependant, nous ne pouvons pas supprimer les lignes vides de début ou de fin qui ont des espaces dans l'entrée. Ceci est implémenté en remplaçant les espaces dans l'entrée par des tabulations (
C9), qui ne peuvent pas être dans l'entrée, en supprimant les lignes vides et en transformant les tabulations en espaces.la source
Python 2, 156 octets
Explication
Le code entier fait simplement un bloc d'espaces (
o) et remplace les bons espaces par les lettres de l'entréet.La variable
lstocke une liste de décalages par le haut. Pour que lencaractère etsoit en lignel[n].Le bytearray
osert de chaîne modifiable, car les chaînes sont immuables en python.-~hest le même queh+1mais économise de l'espace car je n'ai pas besoin de parenthèses.la source
Java,
219209199 octetsJe suis toujours un débutant ici, et j'espère qu'il est conforme aux règles d'introduire une sous-fonction (lorsque les octets de cette fonction sont comptés, bien sûr). Sinon, je vais essayer de convertir la
sinfonction en une recherche de tableau intelligente ...la source
char[]. Ici, cela éliminerait le()onlengthet l'élimineraitcharAt()également. Si je le lis bien, vous pouvez également utiliserprint()au lieu d'println()en enregistrer quelques autres....a<24?s(24-a):-s(a-24);et appelez-la avecs(c%48).Perl, 222 octets
Requiert
-Epoursay, stocke les positions sous forme d'entiers convertis en nombres binaires et le retournement du tableau n'est probablement pas très efficace en octets. De plus, je suis sûr qu'il y a beaucoup d'économies à faire, donc je continuerai à pousser et à pousser.Exemple de sortie:
la source
JavaScript,
251243224220217Implémentation vraiment simple: il utilise une chaîne de caractères pour représenter la position y de chaque caractère sur l'onde (décalé par
a, qui est le code ASCII 97). Il parcourt ensuite toutes les lignes possibles; si la valeur y de la ligne actuelle est la même que la position y sur l'onde, elle écrit un caractère dans la chaîne. Il y a aussi un nettoyage à la fin pour supprimer la ligne si elle s'avère complètement vide.Notez que la sortie apparaîtra dans la
alert()fenêtre si elle n'utilise pas de police à espacement fixe, vous pouvez la modifierconsole.log()pour vérifier que la sortie est correcte.EDIT1:
++et--existent.EDIT2: La suppression des lignes vides se fait maintenant dans la même boucle que le reste, économisant 17 caractères. Je n'ai pas eu besoin de ces crochets non plus, pour 2 caractères supplémentaires.
EDIT3: Pas besoin de déclarer la forme d'onde en tant que variable, enregistrant 4 caractères.
EDIT4: Comme l'a souligné Dom Hastings dans les commentaires, le nombre d'octets comprenait le retour chariot ainsi que le caractère de nouvelle ligne, mis à jour le nombre d'octets pour toutes les révisions pour exclure le retour chariot.
EDIT5: Sauvegardé 3 octets avec la permission de Dom Hastings. Je n'ai pas implémenté le
o.splicecorrectif car cela ne supprime pas les lignes vides (de mon côté, au moins).la source
if(o[i++].trim().length<1)o.splice(--i,1)paro.splice(i-(t=!o[i++].match(/\s/)),t), pour -4,s=prompt() o=[]pars=prompt(o=[]):, -1 etfor(y=0,i=0;y<13;++y){o[i]=""parfor(y=i=0;y<13;++y){o[i]="", -2. Il est probablement possible de combiner vos boucles for aussi pour économiser plus ... Une dernière chose, il convient également de noter que je n'ai que 220 pour votre nombre d'octets actuel, donc vos 225 pourraient être des fenêtres\r\nau lieu de\nce que je suppose que vous pouvez ignorer (veuillez me corriger si je me trompe) ...for(s=prompt(),y=0;y<13;y++,v.trim()&&console.log(v))for(v="",x=0;x<s.length;x++)v+=y=="gfedccbbbaaaaaaabbbccdefghijkklllmmmmmmmlllkkjih".charCodeAt(x%48)-97?s[x]:" "for(s=prompt(y=0);y<13;y++,v.trim()&&console.log(v))for(v="",x=0;x<s.length;x++)v+="gfedccbbbaaaaaaabbbccdefghijkklllmmmmmmmlllkkjih".charCodeAt(x%48)-97-y?" ":s[x]Matlab,
133, 130 octetsLa doublure unique:
Et la version étendue:
La doublure prend l'entrée de la console (
stdin) et fait 130 octets. La version étendue remplace l'entrée console par une définition de fonction (+1 octet) mais est beaucoup plus confortable à utiliser pour le cas de test en boucle:La description:
L'index de ligne de chaque caractère est calculé pour une demi-période, puis mis en miroir et concaténé pour avoir une période complète.
Nous créons un arrière-plan vierge de caractères d'espacement (même longueur que la chaîne d'entrée. Nous plaçons chaque caractère selon sa position dans la ligne appropriée. Si la chaîne d'entrée est plus longue qu'une période, l'
modopérateur (modulo) encapsule cela donc nous ne le faisons pas ' t sortir de la limite lors de la demande du numéro de ligne.Cas de test:
Enregistrez la version de la fonction sous
textsine.mdans votre chemin, puis exécutez:affichera:
si vous voulez tester la version à une ligne avec une entrée de
stdin, votre entrée doit être entrée comme une seulestring, vous devez donc entourer votre entrée entre les'caractères. Exemple:Merci d'
Luis Mendoavoir rasé 3 octets ;-)la source
s=input('');fonctionne toujours.Scala 377 caractères
première Coupe. peut probablement obtenir une meilleure formule à traduire
xenyla source
Lisp commun, 205 octets
Les tests
Voir http://pastebin.com/raw.php?i=zZ520FTU
Remarques
Imprimez la sortie ligne par ligne, en calculant les indices dans les chaînes qui doivent être imprimées à l'aide de la fonction sinus inverse
asin. Les sorties ne correspondent pas exactement aux entrées attendues dans la question, mais comme OP reconnaît que les sorties d'exemple ne sont pas vraiment sinusoïdales, je suppose que c'est correct. Au moins, il n'y a toujours qu'un seul caractère écrit pour chaque colonne.la source
Python 2, 172 octets
Ce n'est pas aussi bon que la réponse d'Alex L , mais c'est assez proche. Prend l'entrée de l'entrée standard et fonctionne mieux dans un
.pyfichier.J'ai décidé de construire la sortie transposée (chaque colonne est une ligne) puis de transposer le résultat, car en python la transposition d'une matrice est
map(*m).l: La représentation binaire de9960000(après avoir coupé le"0b"frombin) est100101111111101001000000. Il s'agit du "pas" de l'onde sinusoïdale de chaque colonne, en commençant par le tout dernier caractère du point le plus bas. Je copie cette liste, j'annule chaque nombre et je le cloue à la fin de lui-même pour former ce qui est effectivement un dérivé de la fonction.s: Il s'agit de la variable qui conserve la trace de la ligne (colonne de la transposition) dans laquelle le caractère suivant est inséré.o: Sortie finale, transposéei: Garde une trace de la période d'onde sinusoïdale. Commence à 9 carlest légèrement décalé.Dans la
forboucle, je crée une liste de 13 espaces (j'utilisais des tableaux croisés mais les listes de caractères se révèlent avoir une instruction d'impression plus courte), puis je remplace lese caractère par le caractère d'entrée. Ajoutezbà la fin deo, ajoutez l'étape appropriéeset incrémentezi.J'avais espéré que la
printdéclaration serait aussi simple que\n'.join(*zip(o)), mais pas de chance.zip(*o+['\n'*13])[::-1]ajoute une colonne de nouvelles lignes, puis inverse et transpose le tout (sans l'inversion, l'onde sinusoïdale est à l'envers),sum(...,())concatène les tuples ensemble en un tuple de caractères, puis''.join(...)concatène les caractères et l'imprime.D'autres choses que j'ai essayées étaient de créer un tableau d'espaces de 12 caractères et d'insérer le nouveau caractère à l'endroit approprié, et de le remplacer
l+=[-c for c in l];par une sorte de calcul avec une sorte de multiplication1et-1avec le résultat de l'indexation dansl, mais rien que je ne pouvais trouver avec fini par être plus court.la source
Mathematica, 131 octets
Cela fait 131 caractères, dont les trois pour
i=foo;. Cela semblait une façon raisonnable de recueillir les commentaires; J'aurais pu le mettre directement dans la définition decet sauvé quelques coups, mais cela semble injuste.C'est assez simple - presque même lisible. Il divise la chaîne en une liste de caractères, puis place ces caractères dans un tableau clairsemé aux positions déterminées à partir de la
Table(tout endroit du tableau auquel aucun caractère n'a été attribué par défaut est un espace). Les lignes sont assemblées séparément, puis des nouvelles lignes saupoudrées entre elles. Le dernier StringJoin assemble le tout.NB: Comme certaines autres solutions, cela peut ne pas être valable car cela produit une véritable sinusoïde plutôt que le (bel) exemple artisanal.
Tests:
la source