Parole e pulsanti cambiano la dimensione del carattere in base a queste regole:A^▲ᴀ^▼

1. La dimensione iniziale del carattere è 11.
2. Se viene premuto quando la dimensione del carattere è 1, la dimensione rimane 1.ᴀ^▼
3. La dimensione del carattere cambia con 1 punto nell'intervallo 1 - 12.
4. La dimensione del carattere cambia con 2 punti nell'intervallo 12 - 28.
5. Le scelte sono 28, 36, 48, 72 e 80 nell'intervallo 28 - 80.
6. La dimensione del carattere cambia con 10 punti nell'intervallo 80-1630.
7. La dimensione del carattere cambia con 8 punti nell'intervallo 1630-1638.
8. Se viene premuto quando la dimensione del carattere è 1638, la dimensione rimane 1638.A^▲

Compito

Nel minor numero di byte possibile, determinare la dimensione del carattere risultante quando viene fornita una serie di pressioni di pulsanti in qualsiasi formato ragionevole.

Esempi

[3,-1,2], che significa : il risultato è 18.A^▲A^▲A^▲ᴀ^▼A^▲A^▲

Alcuni formati possibili sono '^^^v^^', [1 1 1 -1 1 1], [True,True,True,False,True,True], ["+","+","+","-","+","+"], "‘‘‘’‘‘", "⛄️⛄️⛄️🌴⛄️⛄️", 111011, "CaB", ecc ...

[2]: 14

[-1]: 10

[13]: 80

[-11,1]: 2

[11,-1]: 36

[170,-1]: 1630

[2000,-2,100]: 1638

MATL , 49 47 45 byte

11: 9:E10+'$*H'o8:163 10*1638v11ihl180h&Ys0))

Il formato di input è [1 1 -1 1 1 -1 -1 -1]o [2 -1 2 -3], con virgole opzionali.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

11:         % Push [1 2 ... 11]
9:          % Push [1 2 ... 9]
E10+        % Times 2, plus 10: gives [12 14 ... 28]
'$*H'       % Push this string
o           % Convert to double: gives ASCII codes, that is, [36 48 72]
8:163       % Push [8 9 ... 163]
10*         % Times 10: gives [80 90 ... 1630]
1638        % Push 1638
v           % Concatenate everything into a column vector
11          % Push 11
ih          % Input array and concatenate with 11
l180h       % Push [1 180]
&Ys         % Cumulative sum with limits 1 and 180
0)          % Get last value
)           % Index into column vector of font sizes. Implicitly display

Parola VBA, _{199 147 126 116 102 100 87} 85 byte

Perché emulare quando puoi farlo ?!

Funzione dichiarata nel ThisDocumentmodulo che accetta l'input nsotto forma Array(true,true,false,true)e l' output al selettore della dimensione del carattere di Word :P

golfed:

Sub a(n):Set f=Content.Font:For Each i In n
If i Then f.Grow Else f.Shrink
Next:End Sub

Ungolfed:

Sub a(n)
    Set f=ThisDocument.Content.Font
    For Each i In n
        If i Then 
            f.Grow 
        Else 
            f.Shrink
    Next
    ''  Implicitly output font size to MS Word Font Size Selector 
End Sub

.GIF di utilizzo

Grazie

-21 grazie a @ Adám ( Selection.WholeStory:chiamata rimossa )

-10 grazie a @ Adám (assume un ambiente pulito; rimuovi la f.size=11:chiamata)

-14 grazie a @ Adám (selettore della dimensione del carattere della parola di output sfacciato)

-2 grazie a @ Adám (bool ParamArray)

-13 per il cambio ParamArray n()di ne in attesa di input come booleano Array

-2 per passare da un modulo di codice al ThisDocumentmodulo

Vecchia versione 114 byte

Prende l'input ncome ParamArray, sotto forma di true,true,false,truee genera la parola vbe finestra immediata

Sub a(ParamArray n()):Set f=Selection.Font:For Each i In n
If i Then f.Grow Else f.Shrink
Next:Debug.?f.Size:End Sub

Versione precedente, 199 byte

Accetta input sotto forma di 170,-4,6,-1(accetta numeri maggiori di 1 in grandezza)

Sub a(ParamArray n()):Selection.WholeStory:Set f=Selection.Font:f.Size=12:For Each i In n
If i>1 Then
For j=i To 0 Step -1:f.Grow:Next
Else
For j=i To 0:f.Shrink:Next:End If:Next:Debug.?f.Size:End Sub

JavaScript (ES6), 103 101 byte

Accetta input come una matrice di -1/ 1.

a=>a.map(k=>[1,12,28,36,48,72,80,1630,1638].map((v,i)=>n+=n>v&&k*[1,1,6,4,12,-16,2,-2,-8][i]),n=11)|n

Test

let f =

a=>a.map(k=>[1,12,28,36,48,72,80,1630,1638].map((v,i)=>n+=n>v&&k*[1,1,6,4,12,-16,2,-2,-8][i]),n=11)|n

console.log(f([]));
console.log(f([1]));
console.log(f([-1]));
console.log(f([1,1,1,-1,1,1,1,1,1,1,1,1]));
console.log(f(Array(2000).fill(1)));

Risparmiato 2 byte grazie a ETHproductions

Python 2, 111 107 byte

i=10;r=range
for d in input():i+=d*(0<i+d<179)
print(r(1,12)+r(12,29,2)+[36,48,72]+r(80,1631,10)+[1638])[i]

Richiede input per essere nel [-1, 1, 1, -1, ...]formato. Funziona con gli esempi per alcuni byte in più:

for d in input():i=min(max(0,i+d),179)

Ottava, 93 89 87 byte

L'array di input può avere numeri interi maggiori di 1 o inferiori a -1 per rappresentare una molteplicità di azioni

L=11;for k=input(''),L=min(max(L+k,1),180);end;[1:11 [6:14 18 24 36 40:5:815 819]*2](L)

Grazie ad Adám, il linguaggio è cambiato in Octave solo per poter utilizzare l'indicizzazione diretta in un array.

Salvato 2 byte grazie a rahnema1.

Test

Su Ideone

Rubino, 106 byte

Sono riuscito a radere un paio di byte dalla soluzione Python (e ci è voluto un po 'di rasatura).

->n{[*1..12,*(14..28).step(2),36,48,72,*(80..1630).step(10),1638][n.inject(11){|a,b|[0,179,a+b].sort[1]}]}

È una funzione anonima che accetta l'input sotto forma di [1, -1, 1, 1, ...]. Sembra gestire abbastanza bene anche l'input nel modulo [170,-12], ma non posso garantire che funzionerà al 100% delle volte, quindi lo giocherò in modo sicuro e dirò che funziona [1, -1, 1, 1, ...].

Trucchi che ho usato:

• [0,179,a+b].sort[1]: Questo valore a+bdeve essere compreso tra 0 e 179, che sono gli indici validi dell'array di dimensioni del carattere.

• L'uso dell'operatore splat su intervalli li converte in array, quindi vengono generate le dimensioni dei caratteri disponibili [*1..12,*(14..28).step(2),36,48,72,*(80..1630).step(10),1638]. Che è una matrice piatta contenente i valori di ciascuno degli elementi appiattiti:

  • 1..12è un intervallo da 1 a 12 (incluso). L'operatore splat lo trasforma in valori 1, 2, 3, ..., 11, 12.
  • (14..28).step(2)è un enumeratore per l'intervallo dato, in cui ogni passaggio sale di 2. L'operatore splat lo trasforma in valori 14, 16, 18, ..., 26, 28.
  • I singoli valori ( 36, 48, 72, 1638) sono tutti concatenati nella loro posizione nella grande matrice di caratteri.

• Ho usato il metodo inject(/ reduce), che utilizza ogni elemento dell'array di input, riducendoli in una variabile 'memo' (come dice ruby). Inizializzo questo su 11, e il corpo di ogni iterazione di iniezione è di impostare questa variabile di memo sul risultato dell'aggiunta dell'elemento corrente dell'input al valore di memo corrente, e quindi di bloccarlo tra 0 e 180.

Tutti salutano l'operatore splat!

PHP, 116 byte

genera prima l'indice delle dimensioni (da 1 a 180 inclusi),
quindi lo mappa sulla dimensione del punto e stampa il risultato.

for($s=11;$d=$argv[++$i];$s=min($s+$d,180)?:1);echo$s>12?$s>20?$s>23?$s*10-160-2*($s>179):24+(12<<$s-21):$s*2-12:$s;

prende +Ne -1dagli argomenti della riga di comando.
( -Nè accettato anche; basta fare attenzione che la dimensione non salti sotto lo zero!)

Corri con -nr.

Perl 5 , 123 byte

122 byte di codice + 1 per -a

@a=1..12;push@a,map$_*2,7..14;push@a,map$_*($i=10),3.6,4.8,7.2,8..163,163.8;$i=($"=$i+$_)<0?0:$">179?179:$"for@F;say$a[$i]

Provalo online!

Formato di input:

32 -32 12 4 -2