Grafico orizzontale della lunghezza della parola

28

Ingresso

Un elenco di parole separate da un numero qualsiasi di spazi.

Produzione

Un grafico artistico ASCII orizzontale, in cui l'ennesima linea è composta da tanti asterischi ( *) quante l'ennesima parola è lunga.

Esempio di utilizzo

Il >segnale immette l'utente, non è necessario inserirlo durante il test del programma.

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

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

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

Implementazione di riferimento

In caso di dubbi sulla specifica, l'output del programma deve corrispondere esattamente a quello del programma seguente sotto tutti gli input.

puts gets.chomp.split.map{|word| '*' * word.length}.join("\n")
code-golf  ascii-art  string 
— Caridorc
fonte
Quindi è consentita una nuova riga finale? incrocia le dita
— Decadimento beta
@BetaDecay Sì, consentito ...........
— Caridorc,
L'input avrà mai spazi iniziali o finali?
— PhiNotPi
8
Quello che stai descrivendo non è un istogramma. Un istogramma mostrerebbe il numero di parole con caratteri x sulla riga x. Nel primo esempio, la linea 1 avrebbe 0 asterischi (nessuna parola con lunghezza 1) la linea 2 avrebbe 3 asterischi (is, an, of) e così via.
— nitro2k01
1
Ok, mi rendo conto che hai ragione. Orizzontale è.
— nitro2k01,

Risposte:

24

Retina , 5 + 3 = 8 byte

 +
\n
.
*

Ogni riga va nel suo file, quindi ho aggiunto 1 byte per ogni file aggiuntivo. Inoltre, \ndovrebbe essere sostituito con una nuova riga effettiva.

Ogni coppia di linee è una coppia di sostituzione del modello. +corrisponde a uno o più spazi e lo sostituisce con una nuova riga. .corrisponde a qualsiasi carattere tranne una nuova riga e lo sostituisce con a *. Questo viene applicato a livello globale, quindi ogni personaggio viene sostituito con a *.

— NinjaBearMonkey
fonte
11

Pyth, 9 byte

jm*ld\*cz

Spiegazione:

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 byte

r{,'**Nr}h

Come funziona :

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

Provalo online qui

— Optimizer
fonte
10

R - 33

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

dove

  • scan(,"") legge dallo stdin e si divide nello spazio bianco in un vettore di caratteri.
  • gsub(".", "*", ...)sostituisce tutti i caratteri in *.
  • write(..., "") stampa su stdout con "\ n" come separatore predefinito.
— flodel
fonte
10

Python 3, 43 byte:

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

Grazie a @BetaDecay per aver segnalato un errore di sintassi.

Esecuzione di esempio:

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

(La stringa seguente viene inserita come letterale, piuttosto che come testo)

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

Bonus: istogramma verticale

Grazie a @Caridorc per aver sottolineato il mio errore che ha reso i bonus da 1 a molte righe.

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
   **   
   **  *
   **  *
*  ** **
*  ** **
********
********

Bonus: istogramma verticale (sottosopra)

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
Il verticale è spento da uno
— Caridorc,
6

R, 38 byte (con qualche aiuto nei commenti)

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

Come funziona

  • gsub sostituisce tutti gli spazi vuoti con *
  • il secondo gsubaggiunge \n(newline) alla fine di ogni elemento
  • cat stampa di conseguenza

dimostrazione

— David Arenburg
fonte
6

> <> , 38 37 byte

Maledici la custodia del doppio spazio * scuote il pesce *.

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

Puoi provarlo online (tutto ciò che devi fare è dare input attraverso il campo in basso e quindi Givepremere il pulsante). I suggerimenti per l'ulteriore golf sono sempre ben accetti, in particolare idee per rimuovere quegli spazi dispendiosi di fronte alla seconda e terza linea.

Se ti fosse permesso di stampare una nuova riga aggiuntiva per spazi extra, il codice potrebbe essere di ben 27 byte :

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

Spiegazione

Nota: l'ordine della spiegazione corrisponderà alla posizione del puntatore (quindi se il codice viene spiegato in base a ciò che si considererebbe l'ordine, è perché è l'ordine in cui il puntatore lo esegue).

Linea 1:

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

Linea 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

Linea 3:

NB Questa riga va al contrario, quindi leggi da destra a sinistra.

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

Fondamentalmente, il test del programma per assicurarsi che l'input (che viene letto un carattere alla volta) non sia uno spazio e quindi stampa un asterisco. Termina se non è presente alcun input (il valore di input è -1). Per assicurarsi che non stampi nuove righe, utilizza il valore del registro, che imposta su 0 o 1. A causa del modo in cui l'ho impostato, non importa dei valori estranei inseriti nello stack (ad es. il valore del registro quando lo imposta 1dopo aver stampato un asterisco); rimangono nello stack quando il programma termina ma non fanno nulla.

So che potrebbe essere un po 'confuso da quando l'ho usato 84*e 67*invece di " "e "*", rispettivamente, ma era perché non avevo voglia di mettere le stringhe nel programma per qualsiasi motivo.

— ravizzone
fonte
— Beta Decay
6

Javascript ES6

Funzione, 46 caratteri

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

Programma, 55 caratteri

alert(prompt().replace(/\S/g,"*").replace(/\s+/g,"\n"))
— Qwertiy
fonte
La tua funzione in realtà è lunga 46 caratteri e il tuo programma è 55.
— adroitwhiz
@ darkness3560, grazie per la correzione. Ho usato espressioni come "f=s=>s.replace(/\S/g,'*').replace(/\s+/g,'\n')".lengthmisurare la lunghezza e mi sono dimenticato \.
— Qwertiy,
6

Perl, 16 byte (15 caratteri + -p)

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

Correre come:

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

Ho salvato un byte aggiuntivo, grazie a @ThisSuitIsBlackNot , non l'avevo mai incontrato y///sprima!

— Dom Hastings
fonte
Questo è eccellente! È possibile salvare 1 byte modificando la prima sostituzione in una traslitterazione:y/ /\n/s;
— ThisSuitIsBlackNon
@ThisSuitIsBlackNot Ooh nice! grazie!
— Dom Hastings,
5

Gema, 11 9 caratteri

 =\n
?=\*

Esecuzione di esempio:

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'
******
*****
*******
— uomo al lavoro
fonte
5

PHP 5.3, 55 53 51 50 byte

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


Utilizzo:
chiamare lo script e definire una variabile globale ($ a)
php -d error_reporting=0 script.php?a="This is an example histogram of word length"

Output: 

****
**
**
*******
*********
**
****
******
— jrenk
fonte
4

Java, 102 byte

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

Haskell, 31 byte

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

Esempio di utilizzo:

Main> putStr.unlines.map(>>"*").words $ "This is an example histogram of word length"
****
**
**
*******
*********
**
****
******
— Nome del modello
fonte
è possibile sostituire putStr.con f=per ridurre il numero di byte o utilizzare main=interact$invece di putStr.leggere da STDIN e renderlo un programma completo
— HEGX64
@ HEGX64: ma f=unlines.map(>>"*").wordsrestituisce qualcosa di simile "****\n**\n**\n"e non genera un "grafico di arte ASCII orizzontale" come richiesto.
— nimi,
4

CJam, 11 byte

Competere per il secondo posto in CJam dopo che @Optimizer ha trovato una soluzione intelligente a 10 byte. Questa è una soluzione semplice da 11 byte:

lS%:,'*f*N*

Provalo online

Soluzione alternativa che utilizza un ciclo anziché le due mappe, anche 11 byte:

lS%{,'**N}/

Spiegazione per la prima soluzione:

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<"!"?`
`:'*')

Versione più breve usando solo uno replace.

— Cristian Lupascu
fonte
2
Accidenti, ho appena finito la mia funzione ES6, 38 byte. Prendi il mio voto mentre scappo per la vergogna! : D
— MayorMonty
4

J, 10 byte

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

Bonus: verticale (12 byte)

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

Bonus: capovolto verticale (14 byte)

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

Python 3, 72 byte

Una bella fodera :)

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

Produzione:

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

C'è una nuova riga finale qui. Se lo vuoi senza, devi aggiungere 5 byte:

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

Julia, 50 byte

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

Ciò crea una funzione senza nome che accetta una stringa come input e stampa su 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)

Programma, 54 caratteri

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

Funzione, 60 caratteri

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

Esempio di utilizzo:

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>
Espandi frammento

— Patrick Roberts
fonte
3

Matlab - 54 byte

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

Questo viene eseguito dalla console, prenderà una stringa in input da stdine genererà il grafico a parole orizzontale in stdout:

Esempio:

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

Oppure potremmo provare a creare alcune forme fantasiose:

>> 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
Approccio molto intelligente!
— Luis Mendo,
3

Matlab / Octave, 75 byte

Utilizzando una funzione anonima:

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

Grazie a Hoki per aver individuato un errore che ha impedito di rilevare l'ultima parola.

Esempio di utilizzo (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 =
****     
**       
**       
*******  
*********
**       
****     
******

Oppure provalo online (Octave).

— Luis Mendo
fonte
3

PowerShell, 35 31 byte

Abbastanza competitivo per un cambiamento. Vai vai gadget operatori unari. Tengo anche dimenticare che le parentesi su alcune funzioni, come l' -splite -replaceutilizzato qui, sono opzionali.

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

Chiamato tramite input pipeline (equivalente a stdin per PowerShell):

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

Come bonus, se invece possiamo usare argomenti della riga di comando, possiamo ottenere fino a 20 byte e avere qualcosa che funzioni sia con che senza una singola stringa come input:

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

Nuova soluzione (39 byte):

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

Soluzione Regex (42 byte):

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

Soluzione non regex (71 byte):

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

Queste soluzioni definiscono funzioni anonime. Assegnali a variabili o chiamali così:

(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 byte

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

Chiamato con stringhe di codice, ad es a(`This is an example histogram of word length`).

— Fatalize
fonte
2

STATA, 72 byte

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

Si noti che questo codice non funziona nell'interprete online e richiede l'interprete STATA proprietario non libero.

— bmarks
fonte
2

C ++ 14, 107 106 byte

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

O, 22 byte

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

Spiegazione

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

Beam, 92 byte

Questa non è affatto una risposta competitiva e molto piuttosto tardi, ma ultimamente ho giocato un po 'con Beam e volevo vedere se riuscivo a farlo. Finalmente ottenuto un certo successo :)

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

Mostra snippet di codice

— MickyT
fonte
1

AWK

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

esempi

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

produzione:-

****
**
***********
— Shravan Yadav
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.