Costruisci un tornado

31

Secondo me, un tornado assomiglia a questo:

########
#######
 ######
  #####
   ####
   ###
    ##
     #

Questo tornado inizia con la larghezza ne su ogni riga successiva, un carattere viene rimosso da sinistra o da destra, a seconda dell'input.

Ingresso

L'input sarà un elenco di una sorta di due valori univoci (funziona anche una stringa di due caratteri univoci) e un numero intero positivo opzionale per indicare la larghezza iniziale. Se non viene preso l'intero opzionale, la larghezza iniziale è 1 maggiore della lunghezza dell'elenco. Lascia che sia la larghezza iniziale n.

Come fare un tornado

Nel mio esempio, ho scelto la mia lista per contenere 1s e 0s, anche se è possibile scegliere tutti i due valori costanti distinte, o una stringa di due qualsiasi caratteri costanti distinte.

La prima riga sarà composta da caratteri nnon bianchi (puoi scegliere qualsiasi carattere coerente; io scelgo #per il mio esempio).

Quindi, per ogni numero nell'elenco, se il numero è 0, rimuovere il carattere sinistro e creare una nuova riga; se è a 1, rimuovi il carattere giusto e crea una nuova riga.

Pertanto, il tornado sopra è l'output per 8, [1, 0, 0, 0, 1, 0, 0].

Produzione

L'output può essere un elenco di stringhe, un elenco di elenchi di caratteri o una stringa multilinea. È consentito uno spazio bianco finale su ogni riga e è consentita una nuova riga finale alla fine.

Casi test

Questi test includono la larghezza iniziale e gli elenchi di utilizzo di 1, 0.

5, [1,0,0,1]

#####
####
 ###
  ##
  #

10, [1,0,0,1,0,1,0,0,1]

##########
#########
 ########
  #######
  ######
   #####
   ####
    ###
     ##
     #

7, [1,1,1,1,1,1]

#######
######
#####
####
###
##
#

100,
 [1,0,0,0,0,1,0,0,0,1,1,0,1,0,0,1,0,0,1,0,0,1,1,0,1,1,1,1,0,1,0,1,1,0,0,1,0,1,1,0,0,1,1,1,0,0,1,1,1,1,1,0,0,0,1,1,0,1,0,0,1,1,1,1,1,1,1,1,1,1,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,1,0,1,0,1,0,0,1,1,0,0,0,0,1]

Test lungo

Regole

  • Si applicano scappatoie standard
  • Vince il codice più corto in byte! code-golf
  • Lo sfondo non deve essere uno spazio (ho dimenticato di specificarlo prima).
  • La tua lingua deve supportare solo numeri (larghezze) che può gestire, ma se il tuo interprete è stato riscritto con una dimensione numerica più grande, deve teoricamente funzionare.

Implementazione di riferimento

code-golf  ascii-art 
— HyperNeutrino
fonte
3
Dai tuoi esempi sembra che iniziare con sarà sempre 1 maggiore della lunghezza dell'elenco. Potremmo avere un esempio in cui non è così? La larghezza iniziale può essere inferiore alla lunghezza dell'elenco?
— Charlie
@CarlosAlejo No ... Allora non ha senso, perché alla fine non avrai abbastanza elementi da rimuovere ...
— HyperNeutrino,
4
Gli occhiali che @HyperNeutrino utilizzava per vedere il suo primo tornado: i.imgur.com/TzMm94a.png
— Magic Octopus Urn
@MagicOctopusUrn ... lol
— HyperNeutrino,

Risposte:

9

Python 2 , 66 59 byte

-7 byte grazie ad Arnold Palmer 

x,z=input()
for i in range(x):print' '*sum(z[:i])+'#'*(x-i)

Provalo online!

0per rimuovere da destra, 1per rimuovere da sinistra

— asta
fonte
1
ninja'd me: ((((
— Koishore Roy,
Lo stesso qui uomo: /
— Arnold Palmer,
Salva 7 byte sostituendo len(z)+1con xse "numero intero positivo opzionale" significa che non è necessario utilizzarlo. La formulazione della domanda fa sembrare che sia consentita poiché dice "Se non viene preso l'intero opzionale" rispetto a "Se non viene fornito l'intero opzionale".
— Arnold Palmer,
6

vim, 85 82 byte

o"cp:s/#/ <C-v><CR>0"cy$<ESC>"ayy7hR$/<ESC>"bdd:s/[][, ]\+/<C-v><CR>@/g<CR>ggAa#<C-v><ESC><ESC>^D@"^"cy$:2,$:norm D@"

<ESC>è 0x1B, <CR>è 0x0D, <C-v>è 0x16. Ed <ESC>OHè una sequenza multibyte che rappresenta il tasto HOME.

L'input utilizza acome valore "rimuovi a sinistra" e bcome valore "rimuovi a destra".

" @a will remove from the left; @b will remove from the right.
o"cp:s/#/ <C-v><CR>0"cy$<ESC>"ayy
7hR$/<ESC>"bdd

" split the input into digestible chunks
:s/[][, ]\+/<C-v><CR>@/g<CR>
gg

" Create the first line
Aa#<C-v><ESC><ESC>
^D
@"^"cy$

" Create tornado
:2,$:norm D@"

Nessun collegamento TIO, sfortunatamente. Non riuscivo a farlo funzionare sotto V. Test copiando il codice in tornado.vim (sostituendo <ESC>, ecc. Con i loro byte effettivi) ed eseguendo come segue:

$ echo '8, [b, a, a, a, b, a, a]' > a.txt
$ { cat tornado.vim; echo ':wq'; } | vim a.txt
$ cat a.txt

-3 byte a causa del suggerimento di Neil.

— raggio
fonte
Non puoi usare ^invece di ␛OH?
— Neil,
@Neil ^passa al primo carattere non vuoto. ␛OHva al primo personaggio.
— Ray,
1
Ah, scusa, intendevo dire 0che non ...
— Neil,
@Neil In tal caso, sì, dovrei farlo. Grazie.
— Ray,
5

05AB1E , 11 9 byte

-2 byte grazie a Erik the Outgolfer

0×=²v¨yú=

Rimuovi da sinistra: 1
Rimuovi da destra:0

Provalo online!

0×        # Make a string of n 0s
  =       # Print without popping
   ²v     # For each character in input (call it y):
     ¨    #   Remove the last character of the current string
      yú  #   Pad with y spaces
        = #   Print without popping
— Riley
fonte
0×ηsηOha così tanto potenziale ma non riesco a capirlo sotto gli 11 byte.
— Magic Octopus Urn,
Conservare quest'ultima versione e sostituirla ðy×ìcon yú-2.
— Erik the Outgolfer,
4

Retina , 30 28 byte

.?
$`#$&$'¶
T`d`#`#.*
T`d` _

Provalo online! Prende solo una stringa di 0 e 1 e calcola la larghezza in base alla stringa. Spiegazione: Il primo stadio prende la stringa di input e la duplica una volta per ogni punto limite, inserendo a #in quel punto. Il secondo stadio quindi cambia tutte le cifre dopo la #a più #s, creando il triangolo. La terza sequenza quindi cancella tutte le rimanenti e trasforma gli zeri in spazi che si traducono in "oscillazione" del torndao.

— Neil
fonte
3

J, 32 byte

' #'#~[:(],.1+i.@-@#)0,(+/\@:-.)

ungolfed

' #'#~ [: ( ] ,. 1+i.@-@# )  0 , (+/\ @: -.)

Provalo online!

— Giona
fonte
19 byte ' #'#~0(,.#\.)@,+/\, in cui l'input viene invertito dal campione poiché la sfida consente di scegliere i due valori distinti.
— miglia,
@miles ty per questo e l'altro tuo commento. li apprezzo davvero e per favore continua a farli venire.
— Giona,
3

R , 85 82 byte

3 byte salvati grazie a Giuseppe

function(n,l)for(k in 1:n)cat(rep(" ",sum(c(0,l)[1:k])),rep("%",n-k+1),"
",sep="")

Provalo online!

Spiegazione:

function(n,l){
  for(k in 1:n){                      # Proceed line by line
    cat(                              # Concatenate...
        rep(" ",sum(c(0,l)[1:k])),    # ...required number of leading spaces,...
        rep("%",n-k+1),               # ...required number of tornado characters...
        "\n",                         # ...and a new line.
        sep=""                        # Join without spaces
        )
  }
}
— user2390246
fonte
Sapevo che creare una matrice non era l'opzione migliore!
— Giuseppe,
1
82 byte - rasato via {}e usato una nuova riga letterale invece di'\n'
— Giuseppe
3

Haskell, 50 byte

h n=scanl(\s i->[(' ':),id]!!i$init s)$'#'<$[1..n]

Provalo online!

Se l'elenco di input può essere un elenco di nomi di funzioni, possiamo salvare un byte

Haskell, 49 byte

f=id
g=(' ':)
h n=scanl(flip id.init)$'#'<$[1..n]

Esempio di utilizzo: h 5 [g,f,f,g].

Provalo online!

Come funziona:

           '#'<$[1..n]   -- build the first line of the tornado, i.e. n times '#'
scanl(    )              -- repeatedly apply the given function to the starting
                         -- value and the next element of the input list and
                         -- return a list of the intermediate results
  \s i->                 -- the function takes a string s and a number i
            init s       -- and first drops the last element of s
      [    ]!!i          -- and then picks and apply a funtion from the list
        (' ':)           --  i = 0:  prepend a space
        id               --  i = 1:  do nothing
— Nome del modello
fonte
2

Python 2, 58 57 byte

modifica: salvato 1 byte grazie a xnor

l,a=input()
s="#"*l
for i in a+[0]:print s;s=" "*i+s[:-1]

Provalo online!

1 per rimuovere da sinistra, 0 per rimuovere da destra.

— CensoredUsername
fonte
1
Penso che tu possa fare s=" "*i+s[:-1]con sinistra e destra scambiate.
— xnor
2

R , 116 109 102 byte

-5 byte grazie all'utente2390246 (e altri 2 mi sono salvato)

Superato dall'utente2390246

function(n,l){k=cumsum
m=matrix(' ',n,n)
for(i in 1:n)m[k(c(1,!l))[i]:k(c(n,-l))[i],i]='#'
write(m,'',n,,'')}

Provalo online!

Restituisce una funzione anonima che accetta ne un vettore lcon 0per la rimozione da sinistra e 1per la rimozione da destra e stampa il risultato sulla console con la formattazione corretta.

— Giuseppe
fonte
1
Puoi risparmiare un po 'nel calcolare la fine della linea poiché sai che il numero di #s sarà n-i + 1: provalo online! Sebbene ci sia un approccio leggermente migliore se stampi riga per riga anziché costruire una matrice: codegolf.stackexchange.com/a/133720/66252
— user2390246
@utente2390246 molto bello! Sono riuscito a radere via anche un'altra coppia di byte :)
— Giuseppe,
2

Japt , 14 13 byte

-1 byte grazie a @ETH

å+ uP £X+QpV´

L'input è l'array, quindi la dimensione. I valori di matrice sono ""o " ", che rappresentano la rimozione da destra o sinistra, rispettivamente. Utilizza "invece di# e ritorna come una matrice di stringhe.

L'idea qui era quella di creare prima una matrice del padding sinistro per ogni riga, quindi le stringhe di input. Quindi, ogni riga viene "aggiunta la s, usando il fatto che la quantità di "s diminuisce di 1 ogni volta.

Provalo online!

Tutti usano il -Rflag per formattare l'output unendolo a nuove righe.

Spiegazione

å+ uP £X+QpYnV

Implicito: U= input array, V= input number.

å+ uP

Ridurre cumulativamente l'array di input ( å) con la concatenazione di stringhe ( +). Ciò comporta la matrice di ciascun valore intermedio della riduzione. Quindi, anteponi ( u) una stringa vuota ( P) all'array.

£X+

Mappa £ogni valore su se stesso ( X) concatenato con ...

QpV´

Il carattere di citazione ( Q) ripetuto ( p) V--( V´) volte. Anche questo diminuisce Vogni volta.

— Justin Mariner
fonte
Buona Penso che puoi salvare un byte cambiando YnVinV´
— ETHproductions il
@ETHproductions Fantastico, grazie! Ho completamente dimenticato di usare ++o --in Japt.
— Justin Mariner,
2

ArnoldC , 3132 byte

ArnoldC non ha concatenazioni di stringhe, quindi questo crea un tornado da se 8usa 1s per spaziarlo . ArnoldC supporta anche solo numeri interi fino a 16 bit, quindi trabocca con input più lunghi di 7 cifre. (Quindi farà solo mini-tornado)

1è a sinistra, qualsiasi altra cifra è a destra (anche se non lo consiglierei 0, dal momento che non puoi iniziare con quello.)

Ingresso: 1221122

Produzione:

88888888
18888888
18888881
18888811
11888811
11188811
11188111
11181111

Codice golfizzato:

IT'S SHOWTIME
HEY CHRISTMAS TREE d
YOU SET US UP 0
HEY CHRISTMAS TREE e
YOU SET US UP 0
HEY CHRISTMAS TREE m
YOU SET US UP 0
GET YOUR ASS TO MARS m
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
HEY CHRISTMAS TREE l
YOU SET US UP 0
GET YOUR ASS TO MARS l
DO IT NOW g m
DO IT NOW h l m
YOU HAVE BEEN TERMINATED
LISTEN TO ME VERY CAREFULLY g
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE m
GIVE THESE PEOPLE AIR
HEY CHRISTMAS TREE i
YOU SET US UP 2
HEY CHRISTMAS TREE n
YOU SET US UP m
STICK AROUND n
GET TO THE CHOPPER n
HERE IS MY INVITATION n
HE HAD TO SPLIT 10
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE n
GET TO THE CHOPPER i
HERE IS MY INVITATION i
GET UP 1
ENOUGH TALK
YOU HAVE NO RESPECT FOR LOGIC
CHILL
I'LL BE BACK i
HASTA LA VISTA, BABY
LISTEN TO ME VERY CAREFULLY h
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE l
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE m
GIVE THESE PEOPLE AIR
HEY CHRISTMAS TREE o
YOU SET US UP -2
GET TO THE CHOPPER o
HERE IS MY INVITATION o
GET UP l
ENOUGH TALK
HEY CHRISTMAS TREE k
YOU SET US UP 1
STICK AROUND o
GET TO THE CHOPPER k
HERE IS MY INVITATION k
YOU'RE FIRED 10
ENOUGH TALK
GET TO THE CHOPPER o
HERE IS MY INVITATION o
GET DOWN 1
ENOUGH TALK
CHILL
HEY CHRISTMAS TREE p
YOU SET US UP 0
HEY CHRISTMAS TREE f
YOU SET US UP 0
HEY CHRISTMAS TREE i
YOU SET US UP 0
HEY CHRISTMAS TREE q
YOU SET US UP l
HEY CHRISTMAS TREE d
YOU SET US UP 0
HEY CHRISTMAS TREE e
YOU SET US UP 1
HEY CHRISTMAS TREE a
YOU SET US UP 0
HEY CHRISTMAS TREE b
YOU SET US UP 0
HEY CHRISTMAS TREE c
YOU SET US UP l
STICK AROUND q
GET TO THE CHOPPER i
HERE IS MY INVITATION 0
ENOUGH TALK
GET TO THE CHOPPER a
HERE IS MY INVITATION d
ENOUGH TALK
GET TO THE CHOPPER b
HERE IS MY INVITATION e
ENOUGH TALK
GET TO THE CHOPPER c
HERE IS MY INVITATION l
ENOUGH TALK
STICK AROUND c
BECAUSE I'M GOING TO SAY PLEASE a
GET TO THE CHOPPER i
HERE IS MY INVITATION i
GET UP 1
YOU'RE FIRED 10
ENOUGH TALK
GET TO THE CHOPPER a
HERE IS MY INVITATION a
GET DOWN 1
ENOUGH TALK
BULLSHIT
GET TO THE CHOPPER f
HERE IS MY INVITATION b
LET OFF SOME STEAM BENNET c
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE f
GET TO THE CHOPPER i
HERE IS MY INVITATION i
GET UP 1
YOU'RE FIRED 10
ENOUGH TALK
BULLSHIT
GET TO THE CHOPPER i
HERE IS MY INVITATION i
GET UP 8
YOU'RE FIRED 10
ENOUGH TALK
YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE NO RESPECT FOR LOGIC
GET TO THE CHOPPER c
HERE IS MY INVITATION c
GET DOWN 1
ENOUGH TALK
CHILL
GET TO THE CHOPPER i
HERE IS MY INVITATION i
HE HAD TO SPLIT 10
ENOUGH TALK
TALK TO THE HAND i
GET TO THE CHOPPER q
HERE IS MY INVITATION q
GET DOWN 1
ENOUGH TALK
GET TO THE CHOPPER p
HERE IS MY INVITATION m
HE HAD TO SPLIT k
I LET HIM GO 10
ENOUGH TALK
GET TO THE CHOPPER k
HERE IS MY INVITATION k
HE HAD TO SPLIT 10
ENOUGH TALK
GET TO THE CHOPPER f
HERE IS MY INVITATION p
YOU ARE NOT YOU YOU ARE ME 1
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE f
GET TO THE CHOPPER d
HERE IS MY INVITATION d
GET UP 1
ENOUGH TALK
BULLSHIT
GET TO THE CHOPPER e
HERE IS MY INVITATION e
GET UP 1
ENOUGH TALK
YOU HAVE NO RESPECT FOR LOGIC
CHILL
I'LL BE BACK i
HASTA LA VISTA, BABY

Provalo online!

Codice non golfato (5178 byte):

IT'S SHOWTIME
    HEY CHRISTMAS TREE left
        YOU SET US UP 0
    HEY CHRISTMAS TREE right
        YOU SET US UP 0
    HEY CHRISTMAS TREE input
        YOU SET US UP 0
        GET YOUR ASS TO MARS input
        DO IT NOW
        I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
    HEY CHRISTMAS TREE width
    YOU SET US UP 0
    GET YOUR ASS TO MARS width
    DO IT NOW calcwidth input
    DO IT NOW buildline width input
YOU HAVE BEEN TERMINATED

LISTEN TO ME VERY CAREFULLY calcwidth
    I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE input
    GIVE THESE PEOPLE AIR
    HEY CHRISTMAS TREE result
    YOU SET US UP 2
    HEY CHRISTMAS TREE calc
    YOU SET US UP input
    STICK AROUND calc
        GET TO THE CHOPPER calc
        HERE IS MY INVITATION calc
        HE HAD TO SPLIT 10
        ENOUGH TALK
        BECAUSE I'M GOING TO SAY PLEASE calc
            GET TO THE CHOPPER result
        HERE IS MY INVITATION result
        GET UP 1
        ENOUGH TALK
    YOU HAVE NO RESPECT FOR LOGIC
    CHILL
    I'LL BE BACK result
HASTA LA VISTA, BABY

LISTEN TO ME VERY CAREFULLY buildline
    I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE width
    I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE input
    GIVE THESE PEOPLE AIR

    HEY CHRISTMAS TREE ctr
        YOU SET US UP -2
        GET TO THE CHOPPER ctr
            HERE IS MY INVITATION ctr
            GET UP width
        ENOUGH TALK
    HEY CHRISTMAS TREE mask
        YOU SET US UP 1
        STICK AROUND ctr
            GET TO THE CHOPPER mask
                HERE IS MY INVITATION mask
                YOU'RE FIRED 10
            ENOUGH TALK
            GET TO THE CHOPPER ctr
                HERE IS MY INVITATION ctr
                GET DOWN 1
            ENOUGH TALK
        CHILL
    HEY CHRISTMAS TREE digit
        YOU SET US UP 0
    HEY CHRISTMAS TREE decider
        YOU SET US UP 0
    HEY CHRISTMAS TREE result
        YOU SET US UP 0
    HEY CHRISTMAS TREE lines
        YOU SET US UP width
    HEY CHRISTMAS TREE left
        YOU SET US UP 0
    HEY CHRISTMAS TREE right
        YOU SET US UP 1
    HEY CHRISTMAS TREE leftcounter
        YOU SET US UP 0
    HEY CHRISTMAS TREE rightcounter
        YOU SET US UP 0
    HEY CHRISTMAS TREE widthcounter
    YOU SET US UP width
    STICK AROUND lines
        GET TO THE CHOPPER result
            HERE IS MY INVITATION 0
        ENOUGH TALK
        GET TO THE CHOPPER leftcounter
            HERE IS MY INVITATION left
        ENOUGH TALK
        GET TO THE CHOPPER rightcounter
            HERE IS MY INVITATION right
        ENOUGH TALK
        GET TO THE CHOPPER widthcounter
            HERE IS MY INVITATION width
        ENOUGH TALK
        STICK AROUND widthcounter
            BECAUSE I'M GOING TO SAY PLEASE leftcounter
                GET TO THE CHOPPER result
                    HERE IS MY INVITATION result
                    GET UP 1
                    YOU'RE FIRED 10
                ENOUGH TALK
                GET TO THE CHOPPER leftcounter
                    HERE IS MY INVITATION leftcounter
                    GET DOWN 1
                ENOUGH TALK
            BULLSHIT
                GET TO THE CHOPPER decider
                    HERE IS MY INVITATION rightcounter
                    LET OFF SOME STEAM BENNET widthcounter
                ENOUGH TALK
                BECAUSE I'M GOING TO SAY PLEASE decider
                    GET TO THE CHOPPER result
                        HERE IS MY INVITATION result
                        GET UP 1
                        YOU'RE FIRED 10
                    ENOUGH TALK
                BULLSHIT
                    GET TO THE CHOPPER result
                        HERE IS MY INVITATION result
                        GET UP 8
                        YOU'RE FIRED 10
                    ENOUGH TALK
                YOU HAVE NO RESPECT FOR LOGIC
            YOU HAVE NO RESPECT FOR LOGIC

            GET TO THE CHOPPER widthcounter
                HERE IS MY INVITATION widthcounter
                GET DOWN 1
            ENOUGH TALK
        CHILL
        GET TO THE CHOPPER result
            HERE IS MY INVITATION result
            HE HAD TO SPLIT 10
        ENOUGH TALK
        TALK TO THE HAND result
        GET TO THE CHOPPER lines
            HERE IS MY INVITATION lines
            GET DOWN 1
        ENOUGH TALK
        GET TO THE CHOPPER digit
            HERE IS MY INVITATION input
            HE HAD TO SPLIT mask
            I LET HIM GO 10
        ENOUGH TALK
        GET TO THE CHOPPER mask
            HERE IS MY INVITATION mask
            HE HAD TO SPLIT 10
        ENOUGH TALK
        GET TO THE CHOPPER decider
            HERE IS MY INVITATION digit
            YOU ARE NOT YOU YOU ARE ME 1
        ENOUGH TALK
        BECAUSE I'M GOING TO SAY PLEASE decider
            GET TO THE CHOPPER left
                HERE IS MY INVITATION left
                GET UP 1
            ENOUGH TALK
        BULLSHIT
            GET TO THE CHOPPER right
                HERE IS MY INVITATION right
                GET UP 1
            ENOUGH TALK
        YOU HAVE NO RESPECT FOR LOGIC
    CHILL
    I'LL BE BACK result
HASTA LA VISTA, BABY
— TemporalWolf
fonte
Sfortunatamente, non penso che questa risposta sia valida perché limita troppo l'input e modifica l'output in un modo che non è permesso (usando uno sfondo non bianco). Scusate!
— HyperNeutrino,
@HyperNeutrino Abbastanza giusto, questo è buono come puoi ottenere da ArnoldC.
— TemporalWolf,
È un peccato. Mi dispiace perdere tempo e fatica, ma credo che dovrai eliminarlo perché non è valido dalle specifiche della sfida. Puoi chiedere a Meta se ritieni che questa sia la scelta sbagliata e la community può decidere lì cosa fare. Grazie :)
— HyperNeutrino,
1
@HyperNeutrino Non sono convinto che ArnoldC sia automaticamente non valido: funziona per l'intera gamma di numeri interi validi supportati da ArnoldC e non lo "abusa" utilizzando uno spazio più piccolo: se hai scritto nel supporto a 32 bit per ArnoldC, la mia risposta funzionerebbe senza cambiamenti con quella precisione. Le regole non specificano alcun requisito per i caratteri di riempimento, né un tornado di altezza minima che deve essere raggiungibile. Ma aprirò una domanda su meta se preferisci.
— TemporalWolf,
1
Hai ragione. Abbastanza giusto, vai avanti; Ho giudicato male. Bella risposta :)
— HyperNeutrino,
1

Haskell , 67 64 byte

L'input è invertito: 0significa rimuovi a destra e 1rimuovi a sinistra:

f n=zipWith(\x y->(' '<$[1..y])++('#'<$[1..n-x]))[0..].scanl(+)0

Provalo online!

"Ungolfed"

f n = zipWith (\x y-> replicate y ' ' ++ replicate (n-x) '#') [0..] . scanl (+) 0
— ბიმო
fonte
1

C, 68 63 byte

s;f(w,i)int*i;{for(;w;s+=!*i++)printf("%*s%0*d\n",s,"",w--,0);}

Questo utilizza la specifica della larghezza del campo dinamico in una printf()stringa di formato. La funzione si chiama così:

#include <stdio.h>

s;f(w,i)int*i;{for(;w;s+=!*i++)printf("%*s%0*d\n",s,"",w--,0);}

int main() {
    f(8, (int[]){1, 0, 0, 0, 1, 0, 0});
}
— cmaster
fonte
Salva 5 byte rimuovendo int s=0;e mettendo s;prima del f(w,i). In questo modo
— MD XF,
1

JavaScript (ES6), 64 byte

Funzione anonima che accetta parametri nella sintassi del curry (a) (b). Nell'array b una stringa vuota rappresenta la rimozione da destra e uno spazio rappresenta la rimozione da sinistra.

a=>b=>b.reduce((t,v)=>t+'\n'+(a.pop(),p+=v)+a,a=Array(a+1),p='')

Usando 1 e 0 come negli esempi il punteggio è 70

a=>b=>b.reduce((t,v)=>t+'\n'+(a.pop(),v?p:p+=' ')+a,a=Array(a+1),p='')

Test

F=
a=>b=>b.reduce((t,v)=>t+'\n'+(a.pop(),p+=v)+a,a=Array(a+1),p='')

function update() {
  var b=B.value.match(/\d/g)
  
  if (b) {
    b=b.map(v=>+v?'':' ')
    O.textContent = F(b.length+1)(b)
  }
  else
    O.textContent = 'invalid input'
}

update()
  
Input B (0 and 1) <input id=B value='1001' oninput='update()'>
<pre id=O></pre>
Espandi frammento

— edc65
fonte
0

PowerShell , 53 byte

param($a,$b)"#"*$a;0..$a|%{" "*($i+=$b[$_])+"#"*--$a}

Provalo online!

Accetta l'input $acome numero intero opzionale e $bcome matrice di 1e 0s. (Nota che il mio array di 1ed 0è infradito dalla sfida.) Costruisce la linea iniziale #e la lascia sulla pipeline. Quindi passa da0 passa a $a. Ogni iterazione, produciamo un numero eventualmente aumentato di spazi, seguito da un numero pre-decrementato di# . Sì, questo alla fine sputerà una nuova riga vuota, poiché stiamo eseguendo il ciclo al $aposto del numero di elementi nell'elenco.

Tutte le singole stringhe vengono lasciate sulla pipeline e l'output con un separatore newline tra loro è implicito al completamento del programma.

— AdmBorkBork
fonte
0

C #, 181 byte

n=>a=>{var r=new string[n];r[0]=new string('#',n);for(int i=1,p;i<n;++i){r[i]=r[i-1];p=a[i-1]?r[i].LastIndexOf('#'):r[i].IndexOf('#');r[i]=r[i].Remove(p,1).Insert(p," ");}return r;}

Provalo online!

Versione completa / formattata:

class P
{
    static void Main()
    {
        System.Func<int, System.Func<bool[], string[]>> f = n => a =>
        {
            var r=new string[n];
            r[0]=new string('#',n);

            for (int i = 1, p; i < n; ++i)
            {
                r[i] = r[i - 1];
                p = a[i - 1] ? r[i].LastIndexOf('#') : r[i].IndexOf('#');
                r[i] = r[i].Remove(p, 1).Insert(p, " ");
            }

            return r;
        };

        System.Console.WriteLine(string.Join("\n", f(5)(new[] { true, false, false, true })));

        System.Console.ReadLine();
    }
}
— TheLethalCoder
fonte
0

Carbone , 17 byte

ＦＮ«Ｐ×#⁺¹ι¿Ｉ§⮌ηι↑↖

Provalo online! Il collegamento è alla versione dettagliata più vicina del codice. Spiegazione:

ＦＮ«

Il primo input fornisce il numero di iterazioni di loop.

Ｐ×#⁺¹ι

Poiché gli indici di loop sono impostati per default a zero, ne aggiungiamo uno qui per ottenere il numero corretto di #s.

¿Ｉ§⮌ηι

Partendo dalla parte inferiore del tornado e lavorando su si salva un byte, ma è necessario invertire il secondo input in modo da poter indicizzare la cifra corrente.

↑

Se la cifra corrente è a 1, spostati verso l'alto. Questo rende la riga precedente un extra #alla fine.

↖

Se la cifra corrente è a 0, spostati verso l'alto e a sinistra. Questo rende la riga precedente un extra #all'inizio.

— Neil
fonte
0

C # , 159 byte

using System.Linq;n=>a=>new[]{new string('#',n)}.Concat(a.Select((_,i)=>{var s=a.Take(i+1).Count(j=>j==0);var h=n-i-1;return new string('#',h).PadLeft(s+h);}))

Spiegazione

 new[] { new string('#', n) }                //start with n number of hashes
                .Concat(                     //append...
                    a.Select((_, i) =>       //    map each element of array
                    {
                        var s = a.Take(i + 1).Count(j => j == 0);  // count the number of 0's up to, and including, this point
                        var h = n - i - 1;                         // number of hashes for this step
                        return new string('#', h).PadLeft(s + h);  // number of hashes padded left with number of 0s
                    }));

Provalo online!

0

PHP, 136 byte

$b=explode(',',end($argv));$a=$argc==3?$argv[1]:count($b)+1;$c=0;for(;$a;--$a){printf("% {$c}s%'#{$a}s\n",'','');$c+=!array_shift($b);}

Salva in un file php e prova con php file.php 8 '1,0,0,0,1,0,0'. Produzione:

########
#######
 ######
  #####
   ####
   ###
    ##
     #

Purtroppo, preparare l'input è metà del lavoro.

Un'altra versione (158 byte) che utilizza al str_repeatposto di printfe ... gotodi tutte le cose:

$b=explode(',',end($argv));$a=$argc==3?$argv[1]:count($b)+1;$c=0;z:
echo str_repeat(' ',$c).str_repeat('#',$a)."\n";while(--$a){$c+=!array_shift($b);goto z;}
— Ponte Nord
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.