Riempimento di vassoi arbitrari per cubetti di ghiaccio

27

Supponiamo che questa griglia di spazi Xrappresenti la sezione trasversale di alcuni vassoi vuoti di cubetti di ghiaccio dalla forma strana :

   X     X X        
X  X X  XX X  XX   X
XXXXXX XXXXXXXXXXXXX

Le colonne senza Xdi quelle rappresentano buchi o lacune nei vassoi che non possono trattenere l'acqua, drenando in un lavandino a capacità infinita. L'acqua che cade dal bordo più a sinistra o più a destra della griglia entra anche in questo infinito lavandino.

Se dovessimo posizionare un rubinetto sopra i vassoi e lasciarli riempire d'acqua fino a quando il livello dell'acqua in tutti gli scomparti rimane stabile, gli scomparti esatti che si riempiono dipenderebbero esattamente da dove era posizionato il flusso d'acqua sopra i vassoi. (Assumi un flusso d'acqua sottile e costante senza schizzi.)

Ad esempio, se il nostro rubinetto Ffosse sopra la colonna della griglia a sinistra

F                   
   X     X X        
X  X X  XX X  XX   X
XXXXXX XXXXXXXXXXXXX

l'acqua sarebbe caduta fino in cima X in quella colonna e si diffusa a sinistra ea destra, la metà sinistra si riversata nel lavandino sottostante e la metà destra riempito il compartimento 2 × 1. Una volta che il compartimento si riempie, la metà destra del flusso d'acqua non ha alcun posto dove fluire ma nel lavandino e il livello dell'acqua ovunque è sostanzialmente stabile.

Chiudendo il rubinetto, il vassoio ora appare così: (con ~acqua)

   X     X X        
X~~X X  XX X  XX   X
XXXXXX XXXXXXXXXXXXX

Allo stesso modo, se posizioniamo il rubinetto in questo modo:

   F                
   X     X X        
X  X X  XX X  XX   X
XXXXXX XXXXXXXXXXXXX

Riempirà i due scomparti più a sinistra, ma il resto dell'acqua defluirà:

   X     X X        
X~~X~X  XX X  XX   X
XXXXXX XXXXXXXXXXXXX

Se posizioniamo il rubinetto in questo modo:

         F          
   X     X X        
X  X X  XX X  XX   X
XXXXXX XXXXXXXXXXXXX

La metà sinistra del flusso scorrerà nel lavandino ma la metà destra riempirà i tre scomparti più a destra perché non c'è limite a quanto l'acqua può viaggiare orizzontalmente su una superficie piana:

   X     X~X        
X  X X  XX~X~~XX~~~X
XXXXXX XXXXXXXXXXXXX

Posizionato in questo modo, tuttavia:

        F           
   X     X X        
X  X X  XX X  XX   X
XXXXXX XXXXXXXXXXXXX

Tutta l'acqua fuoriesce e nessun compartimento è pieno:

   X     X X        
X  X X  XX X  XX   X
XXXXXX XXXXXXXXXXXXX

Sfida

Scrivi un programma o una funzione che includa una griglia rettangolare di spazi, X"s" e uno F. La riga superiore conterrà sempre il Fe altrimenti contiene solo spazi. IlX 'in ogni colonna (se ce ne sono) si estenderà in una linea continua dalla base della griglia, cioè non ci saranno grotte o sporgenze.

Stampa o restituisci la griglia dopo che il rubinetto Fha riempito ciò che può con l'acqua ~come descritto sopra. Lasciare la Friga superiore fuori dall'output.

  • La griglia a parte la riga del rubinetto sarà almeno 1 × 1

    F
X

    è l'input più piccolo che devi supportare.

  • L'input verrà visualizzato come un rettangolo di testo completo. Gli spazi iniziali e finali contano nell'input e nell'output. ad esempio l'ingresso

        F     
  X  X    
  XXXX

    dovrebbe comportare

      X~~X    
  XXXX

    (notare gli spazi iniziali e finali)

  • Avere una sola nuova riga finale nell'input o output va bene.

  • È possibile utilizzare qualsiasi quattro distinte ASCII stampabili caratteri al posto dello spazio, X, F, ~.

Vince il codice più breve in byte.

Grande esempio:

Ingresso:

                F                                 
              X             X                     
              X             X X                   
X            XXX       X    X X           X    X  
X   X     XXXXXXX      X    XXX     XXXXXXX X  X  
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXX

Produzione:

              X~~~~~~~~~~~~~X                     
              X~~~~~~~~~~~~~X~X                   
X~~~~~~~~~~~~XXX~~~~~~~X~~~~X~X~~~~~~~~~~~X    X  
X~~~X~~~~~XXXXXXX~~~~~~X~~~~XXX~~~~~XXXXXXX X  X  
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXX
code-golf  ascii-art  grid 
— Hobby di Calvin
fonte
Oh sì, una grande opportunità per me di usare la mia amata zip()<3
— cjfaure il
2
Questo ha bisogno di una risposta: / Ci lavorerò sopra.
— TheNumberOne
È relativamente facile creare un automa cellulare che simuli questo, ma non riesco a pensare a un modo per farlo finire.
— DanTheMan,
ancora nessuno per competere? Una sfida così carina. Sembra che dovrò battermi :)
— Jakuje,
— 12Me21

Risposte:

1

perl -p0, 204 + 2 byte

IDEA

  • Se entrambi i lati dell'isola sotto F sono di uguale altezza, sostituire tutti gli X *Xes con X~*Xes su quell'isola.
  • Se un lato è più alto, sostituire tutti gli X *Xes con X~*Xes tra il drenaggio sul lato inferiore e il punto più vicino a F che è più alto della parte superiore del lato inferiore.

La terra direttamente sotto F conta come parte di entrambi i lati qui.

GOLF

s/.*(F).*
//;$f=@-[1];($%,$r)=map{y///c}/(.{0,$f})\bX+?\b(.*)$/;($a,$b)=map{y///c}/[^~]*^(?(?=(.{$%,$f}X)).{$f} *|.{$f} *X(.*)).{$r}
/m;$a=$%if!$a||$b;$b+=$r;s/(?<=.{$a})\b *\b(?=.{$b})/"~"x length($&)/ge

GLI APPUNTI

perl -p0e ' # slurp stdin, print the result

s/.*(F).*\n//; # remove the first line, record the index of F
$f=@-[1]; # get the index of F

($l,$r)=map{length}m/(.{0,$f})\bX+?\b(.*)$/;
# gets the distance from either side to the drains closest to F
($a,$b)=map{length}m/[^~]*^(?(?=(.{$l,$f}X)).{$f} *|.{$f} *X(.*)).{$r}\n/m;
# tries to find the lowest line that has at least one X on
# one side of the island, but none on the other
$a=$l if !$a||$b;
$b+=$r; # use the captured groups to calculate the left and right bounds
s/(?<=.{$a})\b *\b(?=.{$b})/"~" x length($&)/ge;
# replace all pools within those bounds
'

Potrebbe essere difficile riconoscere l'algoritmo originale in questa implementazione poiché Perl non supporta lookbehinds di lunghezza variabile.

— bopjesvla
fonte
6

Lua 5.2, 581 byte

Ancora una volta, inizia lentamente con un linguaggio così inefficace per il golf e con un algoritmo inefficace. Ma migliorerò :)

r=io.read w=io.write F=r()f=F:find("F")o={[1]=F}W=#F i=2 
repeat s=r()if s==nil then break end o[i]={}for j=1,W do o[i][j]=s:sub(j,j)end i=i+1 until false
function e(i,j)
local k,l,b,c=j+1,j-1,false
if i>=#o or(o[i+1][j]==" "and e(i+1,j)==0)then return 0 end
while k<=W do
b=b or o[i][k]=="X"
if b or(o[i+1][k]==" "and e(i+1,k)==0)then break end
k=k+1 end
while l>0 do
c=c or o[i][l]=="X"
if c or(o[i+1][l]==" "and e(i+1,l)==0)then break end
l=l-1 end
if b and c then for m=l+1,k-1 do o[i][m]="~"end return 1 end
return 0 end
e(1,f)for i=2,#o do for j=1,W do w(o[i][j])end w"\n"end

Casi di prova (con fonte d'acqua):

---------
    F    
  X~~X   
  XXXX   
--------------------
         F          
   X     X~X        
X  X X  XX~X~~XX~~~X
XXXXXX XXXXXXXXXXXXX
--------------------
   F                
   X     X X        
X~~X~X  XX X  XX   X
XXXXXX XXXXXXXXXXXXX
--------------------------------------------------
                F                                 
              X~~~~~~~~~~~~~X                     
              X~~~~~~~~~~~~~X~X                   
X~~~~~~~~~~~~XXX~~~~~~~X~~~~X~X~~~~~~~~~~~X    X  
X~~~X~~~~~XXXXXXX~~~~~~X~~~~XXX~~~~~XXXXXXX X  X  
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXX

da bash è possibile provare in questo modo, ma non sembra così bello:

$ echo "    F     
  X  X    
  XXXX   " | lua f.lua
— Jakuje
fonte
Usa here-docs per testarlo più facilmente! Ti piace questa .
— Ravron
1

Javascript, 460 byte

Demo online (su console, testato su Chrome e Firefox attuali).

function e(i,j){var k=j+1,l=j-1,b=0,c=0,I=i+1
if(i>(O-2)||(o[I][j]==" "&&e(I,j)==0))return 0
while(k<W){b=b||(o[i][k]=="X")
if(b||(o[I][k]==" "&&e(I,k)==0))break
k++}while(l>=0){c=c||(o[i][l]=="X")
if(c||(o[I][l]==" "&&e(I,l)==0))break
l--}if(b&&c){for(m=l+1;m<k;m++)o[i][m]="~"
return 1}return 0}function f(d){o=d.split("\n")
F=o[0];s=F.indexOf("F");W=F.length;O=o.length
for(i=0;i<O;i++)o[i]=o[i].split("")
e(0,s);for(i=1;i<O;i++)console.log(o[i].join(""))}

Sfidare me stesso non è così divertente, ma è ancora possibile. Stesso algoritmo di Lua, ora in javascript.

— Jakuje
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.