Graphique horizontal de la longueur des mots

28

Contribution

Une liste de mots séparés par un nombre quelconque d'espaces.

Sortie

Un graphique ASCII horizontal, où la n-ième ligne est composée d'autant d'astérisques ( *) que le n-ième mot est long.

Exemple d'utilisation

L' >entrée des signaux utilisateur, vous ne devez pas la saisir lors du test du programme.

> This is an example histogram of word length
****
**
**
*******
*********
**
****
******

> a aa aaa aaaa aaaaa
*
**
***
****
*****

> double space  example
******
*****
*******

Implémentation de référence

En cas de doute sur la spécification, la sortie de votre programme doit correspondre exactement à celle du programme ci-dessous sous toutes les entrées.

puts gets.chomp.split.map{|word| '*' * word.length}.join("\n")
code-golf  ascii-art  string 
— Caridorc
source
Une nouvelle ligne de fin est-elle autorisée? croise les doigts
— Beta Decay
@BetaDecay Oui, autorisé ...........
— Caridorc
L'entrée aura-t-elle jamais des espaces de début ou de fin?
— PhiNotPi
8
Ce que vous décrivez n'est pas un histogramme. Un histogramme montrerait le nombre de mots avec x caractères sur la ligne x. Dans le premier exemple, la ligne 1 aurait 0 astérisques (aucun mot de longueur 1) la ligne 2 aurait 3 astérisques (is, an, of) et ainsi de suite.
— nitro2k01
1
Ok, je réalise que tu as raison. C'est horizontal.
— nitro2k01

Réponses:

24

Rétine , 5 + 3 = 8 octets

 +
\n
.
*

Chaque ligne va dans son propre fichier, j'ai donc ajouté 1 octet pour chaque fichier supplémentaire. En outre, le \ndoit être remplacé par un véritable retour à la ligne.

Chaque paire de lignes est une paire de remplacement de modèle. +correspond à un ou plusieurs espaces et le remplace par une nouvelle ligne. .correspond à n'importe quel caractère sauf une nouvelle ligne, et il le remplace par un *. Ceci est appliqué globalement, donc chaque caractère est remplacé par un *.

— NinjaBearMonkey
source
11

Pyth, 9 octets

jm*ld\*cz

Explication:

jm*ld\*cz
       cz    chop input on whitespace
 m           map to
   ld        length of the segment
  *  \*      number of asterisks
j            joined on newlines
— isaacg
source
10

CJam, 10 octets

r{,'**Nr}h

Comment ça marche :

r{     r}h         e# This do-while loop basically reads all the whitespace separated tokens
                   e# from input. It separates the tokens on running lengths of whitespace
  ,                e# Take the length of the token
   '**             e# Get a string of that many '*' characters
      N            e# Print a new line

Essayez-le en ligne ici

— Optimiseur
source
10

R - 33

write(gsub(".","*",scan(,"")),"")

où

  • scan(,"") lit à partir de stdin et divise l'espace blanc en un vecteur de caractères.
  • gsub(".", "*", ...)remplace tous les caractères dans *.
  • write(..., "") imprime sur stdout avec "\ n" comme séparateur par défaut.
— flodel
source
10

Python 3, 43 octets:

for w in input().split():print('*'*len(w))

Merci à @BetaDecay d' avoir signalé une erreur de syntaxe.

Exemple d'exécution:

> This is an example histogram of word length
****
**
**
*******
*********
**
****
******

(La chaîne ci-dessous est entrée comme un littéral, plutôt que comme du texte)

> 'example\twith\nweird\rwhite   space'
*******
****
*****
**********

Bonus: histogramme vertical

Merci à @Caridorc d' avoir signalé mon erreur qui faisait que les bonus comportaient 1 à plusieurs lignes.

l=[len(x)for x in input().split()]
for i in range(len(l)-1,0,-1):print(''.join(['*'if j>=i else' 'for j in l]))

Démo:

> This is an example histogram of word length
   **   
   **  *
   **  *
*  ** **
*  ** **
********
********

Bonus: histogramme vertical (à l'envers)

l=[len(x)for x in input().split()]
for i in range(len(l)-1):print(''.join(['*'if j>i else' 'for j in l]))

Démo:

> This is an example histogram of word length
********
********
*  ** **
*  ** **
   **  *
   **  *
   **
— JF
source
La verticale est coupée d'un
— Caridorc
6

R, 38 octets (avec un peu d'aide dans les commentaires)

cat(gsub(" +|$","\n",gsub("\\S","*",x)))

Comment ça marche

  • gsub remplace tous les espaces sans *
  • le deuxième gsubajoute \n(nouvelle ligne) à la fin de chaque élément
  • cat imprime en conséquence

Démo

— David Arenburg
source
6

> <> , 38 37 octets

Malédiction vous double cas d'espace * secoue le poisson *.

<v&0
 >i:84*=?v0(?;67*o&1&
 \ &0o?&a/

Vous pouvez l' essayer en ligne (tout ce que vous avez à faire est de donner votre avis via le champ près du bas, puis d' Giveappuyer sur le bouton). Les suggestions pour continuer à jouer au golf sont toujours les bienvenues, en particulier les idées pour éliminer ces espaces inutiles devant les deuxième et troisième lignes.

Si vous étiez autorisé à imprimer une nouvelle ligne supplémentaire pour des espaces supplémentaires, le code pourrait être un énorme 27 octets :

>i:84*=?v0(?;67*o
^     oa<

Explication

Remarque: l'ordre de l'explication correspondra à l'emplacement du pointeur (donc si le code est expliqué hors de ce que l'on considérerait comme de l'ordre, c'est parce que c'est l'ordre dans lequel le pointeur l'exécute).

Ligne 1:

<v&0
<      redirects flow leftward
   0   pushes 0 onto the stack
  &    pops 0 and puts it in the register 
 v     redirects flow downward

Ligne 2:

>i:84*=?v0(?;67*o&1&
>                     redirects flow leftward
 i:                   pushes input and then duplicates it
   84*                pushes 32 (the space character numerically)
      =?v             pops 32 and input and redirects flow downward if they're equal
         0(?;         pops input and terminates if input is less than 0*
             67*o     pushes 42 (asterisk) and prints it
                 &1&  pushes register value and then puts 1 in the register

*in ><>, the command i returns -1 if no input is given

Ligne 3:

NB Cette ligne va en sens inverse, alors lisez de droite à gauche.

 ^ &0o?&a<
         <  redirects flow leftward
        a   pushes 10 (newline) onto the stack
     o?&    prints a newline if the register is not 0
   &0       sets the register to 0
 ^          redirects flow upwards (back to the second line)

Fondamentalement, le programme teste pour s'assurer que l'entrée (qui est lue un caractère à la fois) n'est pas un espace, puis imprime un astérisque. Il se termine s'il n'y a pas d'entrée (la valeur d'entrée est -1). Pour être sûr qu'il n'imprime pas de sauts de ligne supplémentaires, il utilise la valeur de registre, qu'il définit soit à 0 soit à 1. En raison de la façon dont je le configure, il ne se soucie pas des valeurs étrangères poussées sur la pile (par exemple la valeur du registre lorsqu'il le définit 1après l'impression d'un astérisque); ils restent sur la pile à la fin du programme mais ne font rien.

Je sais que cela peut être un peu déroutant depuis que j'ai utilisé 84*et 67*au lieu de " "et "*"respectivement, mais c'était parce que je n'avais pas envie de mettre des chaînes dans le programme pour une raison quelconque.

— cole
source
— Beta Decay
6

Javascript ES6

Fonction, 46 caractères

f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')

Programme, 55 caractères

alert(prompt().replace(/\S/g,"*").replace(/\s+/g,"\n"))
— Qwertiy
source
Votre fonction
— comporte en
@ obscurité3560, merci pour la correction. J'ai utilisé des expressions comme "f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')".lengthpour mesurer la longueur et j'ai oublié \.
— Qwertiy
6

Perl, 16 octets (15 caractères + -p)

y/ /
/s;s/./*/g

Courir comme:

$ perl -pe 's/ +/
/g;s/./*/g' <<< 'This is a test'
****
**
*
****

Enregistré un octet supplémentaire, grâce à @ThisSuitIsBlackNot , je n'avais jamais rencontré y///sauparavant!

— Dom Hastings
source
C'est excellent! Vous pouvez enregistrer 1 octet en remplaçant la première substitution par une translittération:y/ /\n/s;
— ThisSuitIsBlackNot
@ThisSuitIsBlackNot Ooh nice! Je vous remercie!
— Dom Hastings du
5

Gema, 11 9 caractères

 =\n
?=\*

Exemple d'exécution:

bash-4.3$ gema ' =\n;?=\*' <<< 'This is an example histogram of word length'
****
**
**
*******
*********
**
****
******

bash-4.3$ gema ' =\n;?=\*' <<< 'a aa aaa aaaa aaaaa'
*
**
***
****
*****

bash-4.3$ gema ' =\n;?=\*' <<< 'double space  example'
******
*****
*******
— homme au travail
source
5

PHP 5.3, 55 53 51 50 octets

<?for(;$i<strlen($a);){echo$a{$i++}!=' '?'*':"
";}


Utilisation:
appelez le script et définissez une variable globale ($ a)
php -d error_reporting=0 script.php?a="This is an example histogram of word length"

Sortie: 

****
**
**
*******
*********
**
****
******
— jrenk
source
4

Java, 102 octets

class R{public static void main(String[]a){for(String s:a)System.out.println(s.replaceAll(".","*"));}}
— Koekje
source
4

Haskell, 31 octets

putStr.unlines.map(>>"*").words

Exemple d'utilisation:

Main> putStr.unlines.map(>>"*").words $ "This is an example histogram of word length"
****
**
**
*******
*********
**
****
******
— nimi
source
vous pourriez remplacer putStr.parf= pour réduire le nombre d'octets, ou utiliser main=interact$au lieu de putStr.pour lire à partir de STDIN et en faire un programme complet
— HEGX64
@ HEGX64: mais f=unlines.map(>>"*").wordsrenvoie quelque chose comme "****\n**\n**\n"et ne génère pas de "graphique graphique ASCII horizontal" comme demandé.
— nimi
4

CJam, 11 octets

En concurrence pour la deuxième place dans CJam après que @Optimizer ait trouvé une solution intelligente de 10 octets. Il s'agit d'une solution simple de 11 octets:

lS%:,'*f*N*

Essayez-le en ligne

Solution alternative qui utilise une boucle au lieu des deux cartes, également 11 octets:

lS%{,'**N}/

Explication de la première solution:

l     Get input.
S%    Split at spaces.
:,    Apply length operator to each word.
'*f*  Map each length to corresponding repetitions of '*.
N*    Join with newlines.
— Reto Koradi
source
4

JavaScript (ES6), 37

f=s=>s.replace(/./g,m=>m<"!"?`
`:'*')

Version plus courte en utilisant une seule replace.

— Cristian Lupascu
source
2
Bon sang, je viens de terminer ma fonction ES6, 38 octets. Prenez mon vote positif pendant que je m'enfuis de honte! : D
— MayorMonty
4

J, 10 octets

   '*'$~$&>;:'This is an example histogram of word length'
****     
**       
**       
*******  
*********
**       
****     
******

Bonus: vertical (12 octets)

   |:'*'$~$&>;:'This is an example histogram of word length'
********
********
*  ** **
*  ** **
   **  *
   **  *
   **   
    *   
    *

Bonus: inversé vertical (14 octets)

   |.|:'*'$~$&>;:'This is an example histogram of word length'
    *   
    *   
   **   
   **  *
   **  *
*  ** **
*  ** **
********
********
— hoosierEE
source
3

Python 3, 72 octets

Une belle doublure :)

print(''.join(map(lambda x:"*"*len(x)+"\n"*int(x!=""),input().split())))

Sortie:

>>> print(''.join(map(lambda x:"*"*len(x)+"\n"*int(x!=""),input().split())))
Hello world  how are you?
*****
*****
***
***
****

Il y a un retour à la ligne ici. Si vous le voulez sans, vous devez ajouter 5 octets:

print(''.join(map(lambda x:"*"*len(x)+"\n"*int(x!=""),input().split()))[:-1])
— Beta Decay
source
3

Julia, 50 octets

s->print(join(["*"^length(w)for w=split(s)],"\n"))

Cela crée une fonction sans nom qui prend une chaîne en entrée et imprime sur STDOUT.

Non golfé:

function f(s::String)
    # Construct a vector of horizontal bars
    bars = ["*"^length(w) for w in split(s)]

    # Join the bars with newlines
    j = join(bars, "\n")

    # Print the result to STDOUT
    print(j)
end
— Alex A.
source
3

JavaScript (ES5)

Programme, 54 caractères

alert(prompt().replace(/\S/g,'*').replace(/ +/g,'\n'))

Fonction, 60 caractères

function(i){return i.replace(/\S/g,'*').replace(/ +/g,'\n')}

Exemple d'utilisation:

var h=function(i){return i.replace(/\S/g,'*').replace(/ +/g,'\n')},
d=document,g=d.getElementById.bind(d),i=g('i'),o=g('o')
i.onchange=function(){o.textContent=h(i.value)}
<input id="i"/>
<pre id="o"></pre>
Développer l'extrait

— Patrick Roberts
source
3

Matlab - 54 octets

s=input('');o=repmat('*',1,numel(s));o(s==32)=char(10)

Cela s'exécute à partir de la console, prendra une chaîne en entrée stdinet produira le graphique de mots horizontal dans stdout:

Exemple:

>> s=input('');o=repmat('*',1,numel(s));o(s==32)=char(10)
'This is an example histogram of word length'
o =
****
**
**
*******
*********
**
****
******

Ou nous pourrions essayer de créer des formes fantaisistes:

>> s=input('');o=repmat('*',1,numel(s));o(s==32)=char(10)
'a aa aaa aaaaaa aaaaaaaaaa aaaaaaaaaaa aaaaaaaaaa aaaaaa aaa aa a aa aaa aaaaaa aaaaaaaaaa'
o =
*
**
***
******
**********
***********
**********
******
***
**
*
**
***
******
**********
— Hoki
source
Approche très intelligente!
— Luis Mendo
3

Matlab / Octave, 75 octets

Utilisation d'une fonction anonyme:

@(s)char(arrayfun(@(n)repmat('*',1,n),diff([0 find([s 32]==32)])-1,'un',0))

Merci à Hoki d'avoir repéré une erreur qui a empêché la détection du dernier mot.

Exemple d'utilisation (Matlab):

>> @(s)char(arrayfun(@(n)repmat('*',1,n),diff([0 find([s 32]==32)])-1,'un',0)) % define function
ans = 
    @(s)char(arrayfun(@(n)repmat('*',1,n),diff([0,find([s,32]==32)])-1,'un',0))
>> ans('This is an example histogram of word length') % call function
ans =
****     
**       
**       
*******  
*********
**       
****     
******

Ou essayez-le en ligne (Octave).

— Luis Mendo
source
3

PowerShell, 35 31 octets

Assez compétitif pour un changement. Go go gadget unary operators. J'oublie également que les parens sur certaines fonctions, comme -splitet -replaceutilisées ici, sont facultatifs.

%{$_-split"\s+"-replace".","*"}

Appelé via une entrée de pipeline (équivalent à stdin pour PowerShell):

PS C:\Tools\Scripts\golfing> "a aa aaa" | %{$_-split"\s+"-replace".","*"}
*
**
***

En prime, si nous pouvons à la place utiliser des arguments de ligne de commande, nous pouvons descendre à 20 octets et avoir quelque chose qui fonctionne à la fois avec et sans une seule chaîne en entrée:

$args-replace".","*"

PS C:\Tools\Scripts\golfing> .\horizontal-graph-word-length.ps1 "double space  example"
******
*****
*******

PS C:\Tools\Scripts\golfing> .\horizontal-graph-word-length.ps1 double space  example
******
*****
*******
— AdmBorkBork
source
3

Javascript (ES6)

Nouvelle solution (39 octets):

s=>[...s].map(c=>c==' '?`
`:'*').join``

Solution Regex (42 octets):

s=>s.replace(/\S/g,"*").replace(/ +/g,`
`)

Solution non regex (71 octets):

s=>s.split(" ").map(v=>"*".repeat(v.length)).filter(a=>a!="").join(`
`)

Ces solutions définissent des fonctions anonymes. Attribuez-les à des variables ou appelez-les ainsi:

(s=>s.replace(/\S/g,"*").replace(/ +/g,`
`))("[your string here]")

(s=>s.split(" ").map(v=>"*".repeat(v.length)).filter(a=>a!="").join(`
`))("[your string here]")
— adroitwhiz
source
2

SWI-Prolog, 40 octets

a([A|T]):-(A=32,nl;put(42)),(T=[];a(T)).

Appelé avec des chaînes de code, par exemple a(`This is an example histogram of word length`).

— Fatalize
source
2

STATA, 72 octets

di _r(a)
token "$a"
while ("`1'")!=""{
di _d(`=length("`1'")')"*"
ma s
}

Non golfé

display _request(a) //get input via prompt
tokenize "$a" //split a by spaces into the variables 1,2,...
while ("`1'")!=""{ //while the first variable is not empty
display _dup(`=length("`1'")')"*" //display "*" duplicated for every character in variable 1.
macro shift //move variable 2 to 1, 3 to 2, etc.
}

Notez que ce code ne fonctionne pas dans l'interpréteur en ligne et nécessite l'interpréteur STATA propriétaire non libre.

— bmarks
source
2

C ++ 14, 107 106 octets

#include<iostream>
main(){std::string s;for(;std::cin>>s;){for(char c:s)std::cout<<'*';std::cout<<'\n';}}
— patate douce
source
2

O, 22 octets

i' /rl{e{'.'*%p}{;}?}d

Explication

i                         Read the user input
 ' /r                     Split on spaces and reverse
     l{             }d    For each element
       e           ?      If it's not empty
        {'.'*%            Replace every char with an asterick
              p}          And print it
                {;}       Else, just pop it off the stack
— kirbyfan64sos
source
2

Faisceau, 92 octets

Ce n'est pas une réponse compétitive du tout et vraiment assez tard, mais j'ai joué un peu avec Beam ces derniers temps et je voulais voir si je pouvais le faire faire. J'ai enfin eu du succès :)

'''''''>`++++++)v
vgLsP-(---`<''P'<
>rnp+v
  >Sv>++v
    (>`v+
    H^ )+
^Sp`@p'<+
^  @++++<

Afficher l'extrait de code

— MickyT
source
1

AWK

 awk '{for(i=1;i<=NF;i++){while(k++<length($i)){printf "*"};k=0;print ""}}'

exemples

 echo "this is programming" | awk '{for(i=1;i<=NF;i++){while(k++<length($i)){printf "*"};k=0;print ""}}'

sortie:-

****
**
***********
— Shravan Yadav
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.