Gráfico horizontal do comprimento da palavra

28

Entrada

Uma lista de palavras separadas por qualquer número de espaços.

Saída

Um gráfico de arte ASCII horizontal, em que a n-ésima linha é composta por tantos asteriscos ( *) quanto a n-ésima palavra é longa.

Exemplo de uso

Os >sinais de entrada do usuário, você não deve inseri-lo ao testar o programa.

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

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

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

Implementação de referência

Em caso de dúvida sobre a especificação, a saída do seu programa deve corresponder exatamente à do programa abaixo em todas as entradas.

puts gets.chomp.split.map{|word| '*' * word.length}.join("\n")
code-golf  ascii-art  string 
— Caridorc
fonte
Então, uma nova linha à direita é permitida? cruza os dedos
— Decay Beta 7/15
@BetaDecay Sim, permitido ...........
— Caridorc 7/15/15
A entrada terá espaços à esquerda ou à direita?
— PhiNotPi
8
O que você está descrevendo não é um histograma. Um histograma mostraria o número de palavras com x caracteres na linha x. No primeiro exemplo, a linha 1 teria 0 asteriscos (sem palavras com comprimento 1) a linha 2 teria 3 asteriscos (é, um, de) e assim por diante.
— Nitro2k01
1
Ok, eu sei que você está certo. Horizontal é.
— Nitro2k01

Respostas:

24

Retina , 5 + 3 = 8 bytes

 +
\n
.
*

Cada linha entra em seu próprio arquivo, então adicionei 1 byte para cada arquivo adicional. Além disso, o \ndeve ser substituído por uma nova linha real.

Cada par de linhas é um par de substituição de padrão. +corresponde a um ou mais espaços e o substitui por uma nova linha. .corresponde a qualquer caractere, exceto uma nova linha, e o substitui por a *. Isso é aplicado globalmente, portanto, cada caractere é substituído por a *.

— NinjaBearMonkey
fonte
11

Pitão, 9 bytes

jm*ld\*cz

Explicação:

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

CJam, 10 bytes

r{,'**Nr}h

Como funciona :

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

Experimente online aqui

— Optimizer
fonte
10

R - 33

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

Onde

  • scan(,"") lê stdin e divide no espaço em branco em um vetor de caractere.
  • gsub(".", "*", ...)substitui todos os caracteres em *.
  • write(..., "") imprime no stdout com "\ n" como separador padrão.
— modelo
fonte
10

Python 3, 43 bytes:

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

Obrigado a @BetaDecay por apontar um erro de sintaxe.

Exemplo de execução:

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

(A sequência abaixo é inserida como literal, e não como texto)

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

Bônus: histograma vertical

Agradeço a @Caridorc por apontar meu erro que fez com que os bônus tivessem de 1 a muitas linhas.

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]))

Demo:

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

Bônus: histograma vertical (de cabeça para baixo)

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]))

Demo:

> This is an example histogram of word length
********
********
*  ** **
*  ** **
   **  *
   **  *
   **
— JF
fonte
Vertical está desativado por um
— Caridorc 7/09/15
6

R, 38 bytes (com alguma ajuda nos comentários)

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

Como funciona

  • gsub substitui todos os sem espaços por *
  • segundo gsubadiciona \n(nova linha) ao final de cada elemento
  • cat imprime adequadamente

Demo

— David Arenburg
fonte
6

> <> , 38 37 bytes

Maldito seja o caso de espaço duplo * sacode o peixe *.

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

Você pode experimentá-lo on-line (tudo o que você precisa fazer é fornecer informações através do campo próximo à parte inferior e pressionar o Givebotão). Sugestões para mais golfe são sempre bem-vindas, especialmente idéias para remover esses espaços desnecessários na frente da segunda e terceira linhas.

Se você tiver permissão para imprimir uma nova linha adicional para espaços extras, o código poderá ter 27 bytes :

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

Explicação

Nota: a ordem da explicação corresponderá à localização do ponteiro (por isso, se o código for explicado fora do que seria considerado pedido, é porque é a ordem na qual o ponteiro o executa).

Linha 1:

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

Linha 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

Linha 3:

NB Esta linha é inversa, portanto, leia da direita para a esquerda.

 ^ &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)

Basicamente, o teste do programa para garantir que a entrada (que é lida um caractere de cada vez) não seja um espaço e, em seguida, imprima um asterisco. Ele termina se não houver entrada (o valor de entrada é -1). Para garantir que não imprima novas linhas adicionais, ele usa o valor do registro, que define como 0 ou 1. Por causa da forma como eu o configuro, ele não se importa com os valores estranhos colocados na pilha (por exemplo, o valor do registro quando definido 1após a impressão de um asterisco); eles permanecem na pilha quando o programa termina, mas não fazem nada.

Eu sei que pode ser um pouco confuso desde que eu usei 84*e 67*não " "e "*"respectivamente, mas isso foi porque eu não sentia vontade de colocar strings no programa por qualquer motivo.

— Cole
fonte
— Decay Beta 8/15
6

Javascript ES6

Função, 46 ​​caracteres

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

Programa, 55 caracteres

alert(prompt().replace(/\S/g,"*").replace(/\s+/g,"\n"))
— Qwertiy
fonte
Sua função é realmente 46 caracteres de comprimento, e seu programa é 55.
— adroitwhiz
@ darkness3560, obrigado pela correção. Eu usei expressões como "f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')".lengthpara medir o comprimento e esqueci \.
— Qwertiy
6

Perl, 16 bytes (15 caracteres + -p)

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

Correr como:

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

Salvei um byte adicional, graças a @ThisSuitIsBlackNot , que eu não tinha encontrado y///santes!

— Dom Hastings
fonte
Isto e excelente! Você pode economizar 1 byte, alterando a primeira substituição para uma transliteração:y/ /\n/s;
— ThisSuitIsBlackNot 8/15/15
@ThisSuitIsBlackNot Ooh nice! obrigado!
— Dom Hastings
5

Gema, 11 9 caracteres

 =\n
?=\*

Exemplo de execução:

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'
******
*****
*******
— homem a trabalhar
fonte
5

PHP 5.3, 55 53 51 50 bytes

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


Uso:
chamar o script e definir uma variável global ($ a)
php -d error_reporting=0 script.php?a="This is an example histogram of word length"

saída: 

****
**
**
*******
*********
**
****
******
— empurrão
fonte
4

Java, 102 bytes

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

Haskell, 31 bytes

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

Exemplo de uso:

Main> putStr.unlines.map(>>"*").words $ "This is an example histogram of word length"
****
**
**
*******
*********
**
****
******
— nimi
fonte
você poderia substituir putStr.com f=a diminuir a contagem de bytes, ou usar main=interact$, em vez de putStr.ler de STDIN e torná-lo um programa completo
— HEGX64
@ HEGX64: mas f=unlines.map(>>"*").wordsretorna algo como "****\n**\n**\n"e não gera um "gráfico de arte ASCII horizontal" conforme solicitado.
— nimi
4

CJam, 11 bytes

Competir pelo segundo lugar no CJam depois que o @Optimizer encontrou uma solução inteligente de 10 bytes. Esta é uma solução direta de 11 bytes:

lS%:,'*f*N*

Experimente online

Solução alternativa que usa um loop em vez dos dois mapas, também com 11 bytes:

lS%{,'**N}/

Explicação para a primeira solução:

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
fonte
4

JavaScript (ES6), 37

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

Versão mais curta usando apenas um replace.

— Cristian Lupascu
fonte
2
Caramba, acabei de terminar minha função ES6, 38 bytes. Aceite meu voto enquanto eu corro de vergonha! : D
— MayorMonty
4

J, 10 bytes

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

Bônus: vertical (12 bytes)

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

Bônus: vertical invertido (14 bytes)

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

Python 3, 72 bytes

Um bom forro :)

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

Saída:

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

Há uma nova linha à direita aqui. Se você quiser sem precisar adicionar 5 bytes:

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

Julia, 50 bytes

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

Isso cria uma função sem nome que recebe uma string como entrada e imprime em STDOUT.

Ungolfed:

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.
fonte
3

JavaScript (ES5)

Programa, 54 caracteres

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

Função, 60 caracteres

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

Exemplo de uso:

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>
Expandir snippet

— Patrick Roberts
fonte
3

Matlab - 54 bytes

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

Isso é executado no console, recebe uma string na entrada stdine gera o gráfico horizontal da palavra em stdout:

Exemplo:

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

Ou podemos tentar fazer algumas formas sofisticadas:

>> 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
fonte
Abordagem muito inteligente!
— Luis Mendo
3

Matlab / Octave, 75 bytes

Usando uma função anônima:

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

Agradecemos a Hoki por detectar um erro que impedia que a última palavra fosse detectada.

Exemplo de uso (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 tente online (oitava).

— Luis Mendo
fonte
3

PowerShell, 35 31 bytes

Bastante competitivo para uma mudança. Vá, vá para operadores unitários de gadgets. Também esqueço que parens em algumas funções, como a -splite -replaceusadas aqui, são opcionais.

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

Chamado via entrada de pipeline (equivalente a stdin para PowerShell):

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

Como bônus, se pudermos usar argumentos da linha de comando, podemos chegar a 20 bytes e ter algo que funcione com e sem uma única string como entrada:

$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
fonte
3

Javascript (ES6)

Nova solução (39 bytes):

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

Solução Regex (42 bytes):

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

Solução não regex (71 bytes):

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

Essas soluções definem funções anônimas. Atribua-os a variáveis ​​ou chame-os assim:

(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
fonte
2

SWI-Prolog, 40 bytes

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

Chamado com cadeias de código, por exemplo a(`This is an example histogram of word length`).

— Fatalizar
fonte
2

STATA, 72 bytes

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

Ungolfed

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.
}

Observe que esse código não funciona no intérprete on-line e requer o intérprete STATA não-proprietário e gratuito.

— marcações
fonte
2

C ++ 14, 107 106 bytes

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

O, 22 bytes

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

Explicação

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
fonte
2

Feixe, 92 bytes

Esta não é uma resposta competitiva e realmente muito tarde, mas eu tenho brincado com o Beam recentemente e queria ver se eu conseguiria fazer isso. Finalmente consegui algum sucesso :)

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

Mostrar snippet de código

— MickyT
fonte
1

AWK

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

exemplos

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

saída:-

****
**
***********
— Shravan Yadav
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.