Island Golf # 1: Circumnavigation


43

Questo è il primo di una serie di sfide Island Golf. Prossima sfida

Data un'isola nell'arte ASCII, crea un percorso ottimale per circumnavigarla.

Ingresso

Il tuo input sarà una griglia rettangolare composta da due caratteri, che rappresentano terra e acqua. Negli esempi seguenti, la terra è #e l'acqua è ., ma puoi sostituire due caratteri distinti che desideri.

...........
...##......
..#####....
..#######..
.#########.
...#######.
...#####.#.
....####...
...........

Ci sarà sempre almeno una tessera terra. Le tessere terra saranno tutte contigue (cioè c'è solo un'isola). Le tessere dell'acqua saranno anche contigue (cioè non ci sono laghi). Il bordo esterno della griglia sarà costituito da piastrelle d'acqua. Le tessere terra non saranno collegate in diagonale: cioè non vedrai mai qualcosa di simile

....
.#..
..#.
....

Produzione

Il codice deve generare la stessa griglia, con una circumnavigazione più breve disegnata su di essa. Negli esempi seguenti, viene tracciato il percorso di circumnavigazione o, ma puoi sostituire qualsiasi personaggio purché sia ​​distinto dai tuoi personaggi di terra e acqua.

Una circumnavigazione è una semplice curva chiusa, disegnata interamente su tessere d'acqua, che circonda completamente tutte le tessere di terra sulla griglia. Sono consentite connessioni diagonali . Ad esempio, questa è una circumnavigazione dell'isola sopra (ma non una più breve):

.ooooo.....
o..##.oo...
o.#####.o..
o.#######o.
o#########o
ooo#######o
..o#####.#o
..oo####..o
....oooooo.

La lunghezza di una circumnavigazione viene calcolata come segue: per ogni coppia di tessere adiacenti sul percorso, se sono collegate in orizzontale o in verticale, aggiungi 1; se sono collegati in diagonale, aggiungi √2. La lunghezza del percorso sopra è 22 + 7√2 (≈ 31.9).

Una circumnavigazione più breve è una circumnavigazione con la lunghezza più breve possibile. Il programma dovrebbe generare un percorso qualsiasi che soddisfi questa condizione. Per la maggior parte delle isole, ci saranno più soluzioni possibili. Ecco una soluzione per l'isola sopra, con lunghezza 10 + 13√2 (≈ 28,4):

...oo......
..o##oo....
.o#####oo..
.o#######o.
o#########o
.o.#######o
..o#####.#o
...o####.o.
....ooooo..

Dettagli

La tua soluzione può essere un programma completo o una funzione . Qualsiasi metodo di input e output predefinito è accettabile.

L'input e l'output possono essere una stringa multilinea o un elenco di stringhe. Se la tua lingua ha un tipo di carattere distinto dalle stringhe a carattere singolo, puoi sostituire "elenco di caratteri" con "stringa" nella frase precedente. Se la tua lingua deve inserire l'altezza e / o la larghezza della griglia, puoi farlo. L'output potrebbe (facoltativamente) avere una sola riga finale nuova. Come accennato in precedenza, è possibile utilizzare tre caratteri distinti al posto di #.o(specificare nella presentazione quali caratteri si stanno utilizzando).

Casi test

A. Isole con circumnavigazioni più brevi uniche:

...
.#.
...

.o.
o#o
.o.

......
.####.
......

.oooo.
o####o
.oooo.

......
......
..##..
...#..
......
......

......
..oo..
.o##o.
..o#o.
...o..
......

.......
.#####.
...#...
...#...
.#####.
.......

.ooooo.
o#####o
o..#..o
o..#..o
o#####o
.ooooo.

.......
...#...
...#...
.#####.
...#...
...#...
.......

...o...
..o#o..
.o.#.o.
o#####o
.o.#.o.
..o#o..
...o...

.......
.#####.
.##..#.
..#..#.
.......

.ooooo.
o#####o
o##..#o
.o#..#o
..oooo.

B. Esempio di isola con molteplici possibili soluzioni:

........
....##..
...####.
..###...
.#####..
.#####..
..##....
........

Possibili uscite:

....oo..
...o##o.
..o####o
.o###.o.
o#####o.
o#####o.
.o##oo..
..oo....

....oo..
...o##o.
..o####o
.o###.o.
o#####o.
o#####o.
.o##.o..
..ooo...

....oo..
...o##o.
..o####o
.o###..o
o#####.o
o#####o.
.o##oo..
..oo....

....oo..
...o##o.
..o####o
.o###..o
o#####.o
o#####o.
.o##.o..
..ooo...

C. Caso di prova di grandi dimensioni come sostanza


Questo è : vince il codice più corto in ogni lingua.


1
La circumnavigazione più breve per il terzo caso di test è il modello "pagnotta" nel gioco della vita di Conway!
Compagno SparklePony,

Risposte:


18

Mathematica (versione 9), 165 byte

La simpatica e breve ConvexHullMeshfunzione usata da Greg Martin è stata introdotta solo in Mathematica versione 10, quindi ho pensato di fare un tentativo senza di essa, usando la mia antica Mathematica versione 9. Sono riuscito a renderlo leggermente più breve, però! E 'una funzione che prende e restituisce una lista di stringhe (con ., #e ocome i simboli).

""<>#&/@("o"MorphologicalTransform[MorphologicalComponents[#,Method->"ConvexHull"],Max[#(1-#[[2,2]])CrossMatrix@1]&]+"#"#/.{0->"."})&[Characters@#/.{"."->0,"#"->1}]&

Spiegazione:

  • In primo luogo, Characters@# /. {"."->0, "#"->1}si trasforma l'input in una matrice di 0s e 1s.
  • "o"MorphologicalTransform[MorphologicalComponents[#,Method->"ConvexHull"],Max[#(1-#[[2,2]])CrossMatrix@1]&]+"#"#utilizza quindi le potenti (ma estremamente pesanti byte ...) capacità di elaborazione delle immagini di Mathematica per riempire prima lo scafo convesso dell'isola (che è la forma che otterresti se allungassi un pezzo di corda attorno ad esso), e quindi ne prende il confine. Quindi moltiplichiamo questa matrice per la stringa "o"per ottenere una matrice di 0s "o"(grazie all'impressionante adattabilità di Mathematica sui tipi) e la aggiungiamo a "#"volte la matrice dell'isola.
  • Infine, ""<>#& /@ (... /. {0->"."})trasforma questa matrice di "o"s, "#"s e 0s in una matrice di "o"s, "#"s e "."s e unisce ogni riga in una stringa.

Quando lo testiamo sull'esempio B , otteniamo l'output

{"....oo..",
 "...o##o.",
 "..o####o",
 ".o###..o",
 "o#####o.",
 "o#####o.",
 ".o##oo..",
 "..oo...."}

[Modifica, grazie a Greg Martin:] Se ci è permesso usare matrici di caratteri anziché elenchi di stringhe, possiamo ridurlo a 144 byte:

"o"MorphologicalTransform[MorphologicalComponents[#,Method->"ConvexHull"],Max[#(1-#[[2,2]])CrossMatrix@1]&]+"#"#/.{0->"."}&[#/.{"."->0,"#"->1}]&

1
Ben fatto! Non ne ho mai saputo MorphologicalComponents[#, Method->"ConvexHull"] :) Puoi salvare ancora più byte supponendo che l'input sia già diviso in caratteri e restituendo anche una matrice 2D di caratteri.
Greg Martin,

@GregMartin, non sapevo di quell'uso MorphologicalComponentsfino ad oggi!
Non un albero il

Mathematica novizio qui: come dovrei chiamare questa funzione? Ho provato f[{"...",".#.","..."}]e ho ricevuto alcuni errori.
DLosc

@DLosc, La funzione è tutto, non solo f. (Beh, a rigor di termini è la roba dopo il punto e virgola.) Per chiamare la funzione, digita l'intera cosa in una finestra di Mathematica, seguita da [, il tuo input e ], quindi, dovrebbe assomigliare a f@m_:=m(1-m[[2,2]]) . . . #/.{"."->0,"#"->1}]&[{"...", ".#.", "..."}](abbreviato per spazio).
Non un albero il

@DLosc Beh, è ​​perché il codice è rotto. Penso di averlo risolto ora, però! (Non ho idea di cosa sia successo lì; scusate ...)
Non un albero il

11

(Ma vota la soluzione di Notatree , è meglio!)

Mathematica, 168 byte

(x_~n~y_:=Min[Norm[x-#]&/@y];i=#;p=i~Position~#&;t=p["#"|"."]~Select~#&;(i~Part~##="o")&@@@t[#~n~t[ConvexHullMesh[Join[s=p@"#",#+{.1,.1}&/@s]]~RegionMember~#&]==1&];i)&

Funzione pura che accetta una matrice 2D di caratteri come input e restituisce una matrice 2D di caratteri. Una versione più facile da leggere:

1  (x_~n~y_ := Min[Norm[x - #] & /@ y];
2  i = #; p = i~Position~# &; 
3  t = p["#" | "."]~Select~# &;
4  (i~Part~## = "o") & @@@ 
5    t[#~n~
6      t[ConvexHullMesh[
7        Join[s = p@"#", # + {.1, .1} & /@ s]]
8      ~RegionMember~# &] == 1 &];
9  i) &

La linea 1 definisce una funzione nche produce la (minima) distanza tra un punto xnel piano e una serie ydi altri punti. La riga 2 inizializza la variabile isull'input, sia per risolvere un'ambiguità di curry in seguito sia per essere in grado di modificarla per produrre l'output finale; la linea 2 definisce anche una funzione pche restituisce le coordinate di tutte le occorrenze del suo input i.

Nella riga 3, p["#" | "."]rappresenta ogni singola coordinata dalla mappa di input (poiché tutti i suoi caratteri sono o "#"o "."), quindi tè una funzione che seleziona solo quelle coordinate che soddisfano una proprietà non ancora specificata. Alla riga 4, i~Part~## = "o"cambierà un sacco di voci del ipersonaggio "o"; quei personaggi saranno selezionati dall'insieme di possibili coordinate secondo le cose sulle righe 5-8. E la riga 9 restituisce la risposta una volta calcolata.

Bene, infrastruttura fatta, ora al calcolo effettivo. ConvexHullMeshè il modulo integrato di Mathematica per il calcolo dello scafo convesso di una serie di punti (il poligono convesso più piccolo contenente quei punti). Sul piano morale, questo dovrebbe "riempire" le insenature e i fiordi dell'isola (che è s = p@"#"), per escluderle dalla nostra cicrumnavigazione. C'è un piccolo problema con ConvexHullMeshquando l'insieme di punti è tutto in una riga (grazie, caso di test n. 2), che risolviamo aggiungendo una versione leggermente sfalsata di sse stesso nella riga 7. Questo output è un poligono, quindi le righe 7 -9 (t[...~RegionMember~# &]) produce un elenco di punti con coordinate intere in quel poligono. Infine, la linea 5 e la fine della linea 9 calcolano tutti i punti che si trovano a una distanza esattamente 1 (quindi non 0) da questa serie di punti interi; quell'insieme diventa il percorso circumnavigante.

Di seguito è riportato l'output del caso di test di grandi dimensioni sul collegamento dell'OP. Notare in alto a sinistra, le insolite scelte su quando andare a ovest contro sud-ovest suggeriscono che sta oscurando una linea invisibile di pendenza -2/3 tra due penisole (detto segmento di linea fa parte del confine dello scafo convesso).

........................
.............o..........
...........oo#ooooooo...
..........o#.#.##...#o..
........oo.#.#.###.##o..
.......o..########.##o..
.....oo...############o.
...oo#....############o.
..o#.###.##############o
.o##.##################o
.o####################o.
.o.##################.o.
.o##################..o.
.o..################..o.
o###################..o.
o#####################o.
o.##################.o..
o####################o..
o#...##############.o...
o##...#############o....
o#.....###....#oooo.....
.oooooo#ooooooo.........
.......o................

Mathematica di solito rappresenta le stringhe come array di caratteri 1D? In caso contrario, dovrai invece prendere / restituire una matrice 1D di stringhe. (Inoltre, non vedo l'ora che
arrivi

Mathematica ha un tipo di dati stringa, ma sembra che una serie di caratteri sia valida anche per gli scopi di questo sito (cioè, l'ho imparato quando ho iniziato su PPCG, ma dimentico i motivi legali del perché). Sì, sfortunatamente, Mathematica non è gratuita e quindi non accessibile a molte persone :(
Greg Martin

1
@GregMartin Provo sempre le soluzioni Mathematica su sandbox.open.wolframcloud.com
ovs

Il consenso attuale afferma che gli elenchi di stringhe a carattere singolo non possono essere utilizzati al posto di una stringa. Per quanto ne so, i "personaggi" in Mathematica sono solo stringhe a carattere singolo, come in Python. La situazione è diversa in un linguaggio come Java, che ha un chartipo separato ; in tal caso, un chararray potrebbe essere utilizzato al posto di una stringa.
DLosc

1
Ecco come l'ho letto: la principale risposta votata è stata pubblicata nel 2014. La risposta che ho collegato è stata pubblicata nel 2016, come un tentativo di chiarire l'ambiguità nella risposta precedente. Quindi ho letto il punteggio negativo sulla risposta più recente mentre la gente diceva: "No, non vogliamo che la risposta più vecchia significhi che gli elenchi di stringhe a carattere singolo vanno bene". Ma a prescindere dal meta, sto impedendo gli elenchi di stringhe a carattere singolo in questa domanda (e ho chiarito il testo per riflettere quello).
DLosc

10

Python 3, 779 byte (rientro con schede)

Questo è l'intero programma. Legge l'input da stdin e lo stampa su stdout. Stdin deve terminare con EOF. Esempio eseguito con il grande input: https://ideone.com/XIfYY0

import itertools,sys
L=list
C=itertools.count
d=L(map(L,filter(None,sys.stdin.read().split('\n'))))
X=len(d[0])
Y=len(d)
R=range
def P(r):return all(d[y][x]=='.'for x,y in r)
def S(f):
    for n in C(0):
        if P(f(n)):l=n
        else:break
    for n in C(l+1):
        if P(f(n)):return l,n
def f(V,a,*b):return L(eval('lambda '+a+':('+i+')',V)for i in b)
V=locals()
def D(n):
    y=min(n,Y-1);x=n-y
    while y>=0and x<X:yield(x,y);x+=1;y-=1
def E(n):
    x=max(0,n-Y);y=x+Y-n
    while y<Y and x<X:yield(x,y);x+=1;y+=1
F=f(V,'p','(p,y)for y in R(0,Y)','(x,p)for x in R(0,X)')+[D,E]
r=f(V,'x,y','x','y','x+y','x-y+Y')
B=L(map(S,F))
for x in R(0,X):
    for y in R(0,Y):
        z=L(zip(r,B))
        if all(g(x,y)in R(a,b+1)for g,(a,b)in z)and any(g(x,y)in e for g,e in z):d[y][x]='o'
print('\n'.join(''.join(x)for x in d))

L'idea è semplice: calcola i più piccoli limiti ottagonali e disegna celle che si trovano all'interno di tutti i limiti calcolati e si intersecano almeno uno dei bordi.


1
Non è necessario utilizzare sys.stdincome input. input(), diventare multilinea farebbe il lavoro e costerebbe meno byte
Dead Possum

2
Potrebbe essere in grado di sostituire R(0,x)conR(x)
ceilingcat il

+1 per non usare un built-in.
Robert Fraser,

1
Bello! Altri consigli sul golf: salva 5 byte ciascuno usando lambdas per definire Pe f; L(generator expression)=> [generator expression]; F, re Bsembrano essere utilizzati una sola volta e quindi possono essere incorporati.
DLosc

8

JavaScript (ES6), 369 343 byte

f=s=>(a=s.split`
`.map(s=>[...s]),m=Array(8),a.map((b,i)=>b.map((c,j)=>c>'#'||[i-j,i,j+i,j,j-i,-i,-i-j,-j].map((d,k)=>d>m[k]||(m[k]=d-1)))),[o,p,q,r,t,u,v,w]=m,g=(i,j,k,l,...p)=>i-k|j-l?a[i][j]=g(i+(k>i)-(k<i),j+(l>j)-(l<j),k,l,...p):1/p[0]?g(k,l,...p):'o',g(p,p-o,p,q-p,q-r,r,r-t,r,-u,t-u,-u,u-v,w-v,-w,o-w,-w,p,p-o),a.map(b=>b.join``).join`
`)

Spiegazione: La stringa è divisa in una matrice di caratteri (non sono chiaro se l'input della matrice di caratteri sia accettabile). L'array viene quindi ripetuto e si trovano le posizioni di tutti i quadrati di terra. Le linee che delimitano date dalle equazioni x - y = o, x = p, x + y = q, y = r, y - x = t, -x = u, -x - y = v, -y = wsono determinati in modo tale che il parametro massimo possibile è scelto dove tutti si trova la terra oltre la linea. Ciò ha l'effetto di racchiudere l'isola in un ottagono. Le coordinate degli angoli dell'ottagono vengono prontamente calcolate dai parametri e le celle sul suo bordo vengono riempite. L'array viene quindi ricollegato in una stringa. La ragione per cui è sufficiente un ottagono è la seguente:

   /o#     /o#     /o#
 |/o #   |/o #   |/ o#
 *o###   * o #   *  o#
/|o #   /|o #   /| o#
 |o#     |o#     |o#

Considera un angolo dell'ottagono. Ad un certo punto lungo i due bordi il percorso sarà limitato dalla terra perché abbiamo costruito l'ottagono per toccare la terra il più vicino possibile. Se non c'è terra all'angolo stesso, il percorso potrebbe prendere percorsi alternativi come mostrato a destra, ma questo è sempre lo stesso numero di passi ortogonali e diagonali, quindi la distanza rimane invariata.


Cosa fa ´ ... p´?
Robert Fraser,

@RobertFraser Il nome tecnico è array destrutturante. In questo caso, tuttavia, funge solo da rest of argumentsparametro.
Neil,

@Neil In realtà, il nome tecnico è parametro rest . La stessa sintassi viene utilizzata per l' operatore di diffusione . (Usi entrambi come ...pin luoghi diversi.) La destrutturazione è qualcos'altro (sebbene l'operatore di diffusione possa essere usato nella destrutturazione).
Brian McCutchon,

@BrianMcCutchon Hai ragione, intendevo operatore di diffusione, ma in ogni caso lavori di destrutturazione negli elenchi di argomenti.
Neil,

6

Python 3.5, 224, 263, 234 218 byte

Ha golfato altri 16 byte eliminando la funzione nidificata e rendendola una linea.

def h(s,k=0,i=0):w=s.find('\n')+1;x=s.find('X')-w;k=k or x;d=[1,w+1,w,w-1,-1,-w-1,-w,-w+1]*2;u=s[:k]+'o'+s[k+1:];return['X'>s[k]and i<8and(h(u,k+d[i+2],i+2)or h(u,k+d[i+1],i+1)or h(u,k+d[i],i))or'',s][s[k]>'X'and k==x]

Golfato fuori 29 byte:

def f(s):
 w=s.find('\n')+1;x=s.find('X')-w;d=[1,w+1,w,w-1,-1,-w-1,-w,-w+1]*2
 def h(s,k,i):u=s[:k]+'o'+s[k+1:];return['X'>s[k]and i<8and(h(u,k+d[i+2],i+2)or h(u,k+d[i+1],i+1)or h(u,k+d[i],i))or'',s][s[k]>'X'and k==x]
 return h(s,x,0)

L'input è una singola stringa che usa '~' per ocean, 'X' per land e 'o' per il confine. (Usando 'X' si salva un byte per '>' invece di '==')

Versione meno giocata a golf con commenti:

def f(s):
    w=s.find('\n')+1                         # width of one row
    x=s.find('X')-w                          # starting point
    d=[1,w+1,w,w-1,-1,-w-1,-w,-w+1]*2        # delta to add to current index to move in 
                                             # the 8 directions: E, SE, S, SW, W, NW, 
                                             # N, NE. Make it long to avoid
                                             # lots of modulo operations in 
                                             #    the recursive calls

    def h(s,k,i):                            # s is the island string, k the current
                                             # position, i the direction index
        if s[k]>'X'and k==x:                 # if back at the begining,
            return s                         #   return the map

        elif 'X'>s[k] and i<8:               # if there is water here, and haven't
                                             #  looped around,
            u=s[:k]+'o'+s[k+1:]              #  make a new map with an 'o' in the 
                                             #  current spot

            r = h(u,k+d[i+2],i+2)            # try a 90 degree right turn
            if r: return r

            r = h(u,k+d[i+1],i+1)            # try a 45 degree turn
            if r: return r

            r= h(u,k+d[i],i)                 # try straight ahead
            if r: return r

        return ''                            # this path failed

    return h(s,x,0)

@DLosc risolto. (dovrei eliminare la vecchia risposta?)
Root Due

Bello! (Sì, dovresti rimuovere la vecchia risposta - se qualcuno vuole vederla, può guardare la cronologia delle revisioni del post.)
DLosc

5

C # 7 - 414 369 327 byte

Modifica : passa al loop 1D, al calcolo ie jal volo

Modifica : metodo di input modificato, tabella di ricerca compressa e passaggio a limiti iniziali ben definiti ... e rimosso lo spazio inutile nell'ultimo ciclo esterno

using C=System.Console;class P{static void Main(){var D=C.In.ReadToEnd().Replace("\r","");int W=D.IndexOf('\n')+1,H=D.Length,z=H,k,q,c;int P()=>z%W*(k%3-1)+z/W*(k/3-1)+H;var B=new int[9];for(;z-->0;)for(k=9;k-->0&D[z]%7<1;)if(B[k]<=P())B[k]=P()+1;for(;++z<H;C.Write(q>9?'o':D[z]))for(q=k=9;k-->0;)q*=(c=P()-B[k])>0?0:c<0?1:2;}}

Provalo online

Il programma completo, riceve l'input alla norma, lo stampa fuori norma, usi #, .e o. Per ogni cella, calcola un 'profilo' (che è la distanza su 8 direzioni (sembra calcolare un nono per comodità, ma questo è sempre 0) e registra un massimo di ciascuno di essi. Quindi scrive l'intera mappa di nuovo, e sostituisce qualsiasi cella che si trova sia su un confine che non al di fuori di qualsiasi con una "o". Il codice commentato di seguito spiega come funziona tutto.

Secondo la mia risposta a Save the Geese from Extinction , questo produce il più piccolo ottagono (circumnavigazione valida con la più grande area) che delimita l'isola.

Nota : per una volta nella mia vita sto usando qualcosa del decennio in corso, e questo codice richiede C # 7 per la compilazione. Se non si dispone di C # 7, è necessario sostituire una riga, che è chiaramente indicata nel codice.

Esempio di utilizzo e output:

type t7.txt | IslandGolf1.exe

.........ooooooooooo....
........o....#......o...
.......o...#.#.##...#o..
......o....#.#.###.##.o.
.....o....########.##..o
....o.....############.o
...o.#....############.o
..o#.###.##############o
.o##.##################o
o.####################.o
o..##################..o
o.##################...o
o...################...o
o###################...o
o#####################.o
o.##################..o.
o####################o..
o#...##############.o...
o##...#############o....
o#.....###....#...o.....
.o.....#.........o......
..ooooooooooooooo.......

Codice formattato e commentato:

using C=System.Console;

class P
{
    static void Main()
    {
        // \n 10
        // # 35
        // . 46
        // o 111


        var D=C.In.ReadToEnd().Replace("\r",""); // map

        int W=D.IndexOf('\n')+1, // width
            H=D.Length, // length
            z=H, // position in map (decomposed into i and j by and for P)
            k, // bound index
            q, // bound distance, and later cell condition (0 -> outside, 8 -> inside, >8 -> on boudary)
            c; // (free), comparison store

        // 'indexes' into a profile for the point z at index k
        // effectively {i=z%W,j=z/W,-i,-j,i+j,j-i,-i-j,i-j,0}[k] (inside order is a bit different) (0 const is always treated as 'inside bounds')
        // each non-zero-const entry describes the distance in one of the 8 directions: we want to maximise these to find the 'outer bounds'
        // the non-zero-const bounds describe 8 lines, together an octogen
        int P()=>z%W*(k%3-1)+z/W*(k/3-1)+H; // new C#7 local method syntax (if you don't have C#7, you can test this code with the line below instead)
        //k=0;System.Func<int>P=()=>z%W*(k%3-1)+z/W*(k/3-1)+H; // old lambda syntax (must pre-assign k to make static checker happy)

        var B=new int[9]; // our current bounds, each is initially null (must only call P() when on a #)
        // B[k] starts off a 0, P() has a +H term, and W+(H/W)<H for W >= 3, so B[k] is assigned the first time we compare it (H-i-j always > 0)

        for(;z-->0;) // for each cell
            for(k=9;k-->0& // for each bound
                D[z]%7<1;) // if this cell is #
                if(B[k]<=P())B[k]=P()+1; // update bound if necessary (add one so that we define the bound _outside_ the hashes)
        // z=-1
        for(;++z<H; // for each cell
                C.Write(q>9?'o':D[z])) // print the cell (if q > 9, then we are on the bounds, otherwise, spit out whatever we were before)
            // check we are not 'outside' any of the bounds, and that we are 'on' atleast one of them
            for(q=k=9;k-->0;) // for each bound
                q*=(c=P()-B[k])>0?0: // outside bound (q=0)    (??0 is cheaper than (int) or .Value)
                    c<0?1: // inside (preserve q)
                    2; // on bound (if q != 0, then q becomes > 9)
    }
}

ottagono più grande? o il più piccolo?
Sarge Borsch,

@SargeBorsch grazie, risolto il testo.
VisualMelon
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.