Per la pratica del golf, ho svolto i compiti nella lezione Intro to Python della mia ragazza. Ho scoperto che per questo incarico, c'erano molte strategie che si avvicinavano molto al conteggio dei personaggi e sono sicuro che le persone qui possono trovare modi ancora migliori. Anche se sono più interessato ai modi per farlo in Python, vorrei sapere il massimo golf che questo programma può ottenere, quindi questo è il codice golf e la risposta più corta vince.

Le regole:

L'incarico è delineato di seguito. All'utente dovrebbe essere chiesto di inserire due volte, anche se i prompt non devono dire nulla e possono essere in un ordine diverso.

Si applicano scappatoie standard.

Assegnazione 3: frecce

Scrivi un programma che richiede all'utente un numero di colonne e queste stampano il modello come mostrato di seguito. Si può presumere che l'utente fornirà numeri positivi. Il tuo programma dovrebbe gestire entrambe le frecce sinistra e destra. Ecco alcuni esempi di esecuzione:

How many columns? 3
Direction? (l)eft or (r)ight: r
*
 *
  *
 *
*
How many columns? 5
Direction? (l)eft or (r)ight: l
    *
   *
  *
 *
*
 *
  *
   *
    *

Pyth, 23 byte

Può o meno essere valido, in base alla risposta a questo commento . Indipendentemente da ciò, ho trovato questo pulito e, se non è valido, anche le altre risposte di Pyth non sono valide. ;) Beh, è valido , perché a quanto pare mi è sfuggito palesemente ovvio. : /

EDIT: HO VINTO !!!! YESSS !!!! La prima volta in assoluto! : D

j+_J_Wqz\r.e+*dkb*\*QtJ

Dimostrazione dal vivo.

Pyth, 27

j<tQ_Wqz\l++Jm+*\ d\*Q_PJtJ

Provalo online

L'idea di base qui è costruire una stringa che, per esempio 5, assomigli a questo:

*
 *
  *
   *
    *
   *
  *
 *
*
 *
  *
   *
    *

E poi capovolgilo se otteniamo lcome input. Quindi prendiamo tutti tranne le ultime input-1righe di questa stringa e la stampiamo.

Python 2, 81 79 byte

c=input()
r=1
l=0
exec"print' '*(%sabs(c-r))+'*';r+=1;"%("c+~"*input())*(2*c-1)

Potrebbe essere ancora giocabile a golf, ma vedremo :)

Pyth, 30 28 27 byte

VtyQ+*+*tQJqz\r_WJ.a-hNQd\*

Provalo online.

Apparentemente sono attualmente legato a FryAmTheEggman con un approccio completamente diverso. (Penso che uno sia geniale.)

Esempio

$ python pyth.py spa.p
r
3
*
 *
  *
 *
*

$ python pyth.py spa.p
l
5
    *
   *
  *
 *
*
 *
  *
   *
    *

Spiegazione

 tyQ                              (columns * 2) - 1
V                               loop N through range(the above)
        tQ                                columns - 1 (maximum number of spaces)
       *                                multiplied by
           qz\r                           1 if direction == "r" else 0
          J                               also save that 1 or 0 to J
      +                               plus
                  .a-hNQ                    abs(N - columns + 1)
               _WJ                      negate that if direction == "r"
     *                  d           that many spaces
    +                    \*       add the star and print

PowerShell, 91 85 102 byte

$c=(Read-Host)-1;if(!$c){"*";exit}(@(0..$c+($c-1)..0),@($c..0+1..$c))[(Read-Host)-eq'l']|%{" "*$_+"*"}

• Ottiene le colonne, le memorizza in $c. *Ne sottraggiamo uno perché ogni colonna ha anche un e siamo interessati solo a quanti spazi sono richiesti.
• Se il valore inserito era a 1, stampa *ed esci - il resto dello script non fa differenza. ⁺
• La sezione successiva prima ottiene la direzione e verifica se lo è -eq reale l, quindi crea un array basato sull'indicizzazione in un array di array generati dinamicamente in base al valore di$c . Magia. In sostanza, questo è di quanti spazi per linea abbiamo bisogno.
• Ad esempio, per 5 r questa raccolta verrebbe trattenuto (0,1,2,3,4,3,2,1,0).
• Prende l'array e lo instrada in un %ciclo Foreach-Object , dove viene emessa una stringa di X numero di spazi, quindi il*

Esempio di utilizzo:

PS C:\Tools\Scripts\golfing> .\simple-printing-arrows.ps1
6
r
*
 *
  *
   *
    *
     *
    *
   *
  *
 *
*

_{Modifica: rimossa la variabile $eeseguendo il piping della raccolta direttamente
Modifica2: ora rappresenta correttamente 1 colonna}

⁺ Se è ancora obbligatorio inserire input per la direzione per le frecce a 1 colonna (suppongo che non lo sia), possiamo scambiare il posizionamento di Read-Hoste perdere un paio di byte reintroducendo la $dvariabile, per 106 :

$c=(Read-Host)-1;$d=Read-Host;if(!$c){"*";exit}(@(0..$c+($c-1)..0),@($c..0+1..$c))[$d-eq'l']|%{" "*$_+"*"}

TI-BASIC, 75 65 57 54 50 47 byte

Grazie a @ThomasKwa per il corretto calcolo dei byte e il golf 10 byte .

Testato sul mio TI-84 + Silver Edition.

Prima presentazione TI-BASIC, suggerimenti di golf benvenuti (non conosco ancora molti trucchi). Se il nome gioca un fattore nella memoria mostrato, questo era di 3 caratteri invece di 1 (ho guardato il conteggio dei byte sulla mia calcolatrice stessa). Questo programma è limitato dalle outputrestrizioni della funzione (penso alle frecce di lunghezza 4), ma probabilmente potrei passare a text, che viene visualizzato graficamente se è troppo lungo di lunghezza.

Prompt L,Str1
Str1="R
For(I,1,2L-1
Output(I,(1-2Ans)abs(I-L)+AnsL+1,"*
End

Nota che anche questo non cancella lo schermo o lo mette in pausa.

Sento davvero che l'equazione che sto usando può essere giocata di più. È anche così sbagliato escludere le virgolette finali.

Python 2, 89 byte

c=input()-1
d=raw_input()>'l'
for j in range(2*c+1):print' '*(d*c-(2*d-1)*abs(c-j))+'*'

Funziona in modo quasi identico alla mia risposta Pyth, calcolando semplicemente il numero corretto di spazi al volo.

PowerShell, 104 102 97 byte

# 97 version:
$o=@(($c=(read-host)-1))[(read-host)-eq'l'];($j=2*$c)..0|%{' '*[Math]::Abs($o++%($j+!$j)-$c)+'*'}

3
r
*
 *
  *
 *
*

# Previous 102 version:
$o=@(($c=(read-host)-1))[(read-host)-eq'l'];(2*$c)..0|%{
' '*[Math]::Abs($o++%(2*($c+(!$c+0)))-$c)+'*'}

NB. se si desidera eseguirlo nuovamente, aprire un nuovo PowerShell orv o ripristinare lo stato variabile.

Rispetto a quanto sono concisi gli altri, questo fa male. [Fa meno male a 97 che a 122]. Due parti, nessuna delle quali molto sorprendente; legge un numero di colonne, utilizza un array-index-ternary-operator-substitute per ottenere un offset e scorre una funzione d'onda a partire dall'offset (e un tweak in modo che non cada nel faremod 0 ).

(E ahi ho speso anni in quella funzione d'onda, incapace di individuare il mio malinteso, e digitando tutto il non-LISP-, i genitori onesti).

Python 2, 98 89 byte

f=[' '*n+'*'for n in range(input())]
if'l'==input():f=f[::-1]
print'\n'.join(f+f[-2::-1])

Un po 'più lungo.

uso

$ python2 test.py
3
"l"
  *
 *
*
 *
  *

Perl, 85 byte

($-,$_)=<>;$,=$/;@}=map$"x$_.'*',0..--$-;@}=reverse@}if/l/;print@},map$}[$--$_],1..$-

Uso:

perl 59874.pl <<< '6
r'

PHP, 156 byte

<?for($c=1+fgets(STDIN);--$c;$s[-$c]=$t[]=sprintf("%{$c}s","*"));arsort($s);$a=fgetc(STDIN)==r?$s+$t:$t+$s;array_splice($a,count($a)/2,1)?><?=join("
",$a);

Crea due array, in questo modo:

$t = [
    0 => "  *"
    1 => " *"
    2 => "*"
]
$s = [
    -1 => "*"
    -2 => " *"
    -3 => "  *"
]

quindi utilizza l'unione array $s+$to $t+$sper combinarli e array_splicerimuovere l'elemento nel mezzo. Finalmente prodotto usando<?=join()

Python 2, 111 109 104 byte

Soluzione abbastanza semplice. Sono sicuro che può essere giocato a golf di più. Per chi non lo sapesse, ~x+nè lo stesso di n-1-x.

n=input()
r=range(n)
r+=r[-2::-1]
for i in[r,[~x+n for x in r]]['r'>raw_input()]:print"*".rjust(i+1," ")

Provalo online

Modifica : questo è stato golfato nell'ultima riga:

if'r'>d:r=[~x+n for x in r]
for i in r:print"*".rjust(i+1," ")

Matlab, 109 105 96 byte

Grazie a @beaker per avermi salvato 9 byte .

x=eye(input(''));if(input('','s')<114),x=fliplr(x);end
x=x*10+32;disp(char([x;x(end-1:-1:1,:)]))

Rubino, 118 byte

2.times{l,d=gets.split;l=l.to_i;a=(d=="r"?(0..l-1):(l-1).downto(0)).to_a;(a+a[0..-2].reverse).each{|x| puts "#{' '*x}*"}}

2.times{ - due volte, ovviamente ...

l,d=gets.split; - ottieni l'input

l=l.to_i; - cambia la lunghezza in un numero intero

a=(d=="r"?(0..l-1):(l-1).downto(0)).to_a; - crea un array dall'intervallo 0 alla lunghezza

(a+a[0..-2].reverse).each{|x| puts "#{' '*x}*"} - iterare, girare nelle stringhe per creare le frecce

Non esattamente il più grande golf di sempre, ma, ehi.

PowerShell, 98 94 byte

$c=(Read-Host)-1;$d=Read-Host;if($c){$c..0+1..$c|%{if($d-eq'r'){$_=$c-$_}' '*$_+'*'}}else{'*'}

Se potessi trovare un modo per mettere l'host di lettura per la direzione all'interno del ciclo foreach-object, ma richiederlo solo una volta potrei essere in grado di salvare qualche byte.

Modifica: 94 byte. Invece di testare a sinistra, prova a destra (semplifica il loop).

98 byte originali:

$c=(Read-Host)-1;$d=Read-Host;if($c){0..$c+($c-1)..0|%{if($d-eq'l'){$_=$c-$_}' '*$_+'*'}}else{'*'}

> <> , 60 byte

i"1l"i=&-:&*&:?!\:1-:}c0.
~/?:<-$?&::&;!?l<oao"*"
1/  \o" "-

2 byte sprecati nella linea di fondo, che irritazione!

A causa del modo in cui l'input funziona in> <>, non è possibile "attendere" l'input: il icomando verifica se un carattere di input è disponibile su STDIN. Se c'è, spinge il valore ASCII di quel carattere e spinge -1 se no.

Ciò significa che, per utilizzare questo programma, il numero e la direzione devono essere già pronti su STDIN, ad esempio 3rper una freccia di dimensione 3 che punta a destra. Non sono sicuro se questo squalifica questa voce, fammi sapere i tuoi pensieri: o)

Scriverò anche una descrizione se qualcuno lo desidera.

PHP, 154 byte

Sembra davvero ripetitivo, ma fa il desiderato:

$c=$argv[1];$b=l==$argv[2]?1:0;$a=$b?$c:-1;function a($a){echo strrev(str_pad('*',$a))."\n";}while($b?--$a:++$a<$c)a($a+1);while($b?++$a<=$c:1<$a--)a($a);

Viene eseguito dalla riga di comando come:

php arrow.php 5 l
php arrow.php 5 r

Python, 88 byte

Modificato

n=input()-1
x=raw_input()>'l'
for i in range(2*n+1):print" "*(n*x+(-1)**x*abs(n-i))+"*"