Crea una funzione o un programma che renda una griglia il più vicino possibile a un quadrato

• Ti verrà dato un numero intero N come input, numeri interi (1,2,3,25, ecc.)
• L'output deve essere una griglia rettangolare perfetta di N lettere il più vicino possibile a un quadrato
• Il quadrato (aspirante) deve essere costituito da una delle lettere O o X come specificato dall'utente

Punti :

• Hardcoded su solo O o X: +1
• Un parametro (0/1, vero / falso, qualcosa di simile) per ruotare l'uscita (come con 5 o 8): -10
• Disegna il quadrato (usa sia O che X in una sorta di modello): -5

Un modello è considerato valido se contiene entrambi i tipi di caratteri (dove asse x / y> = 3) e il modello rimane lo stesso quando capovolto in senso orizzontale o verticale (è consentito lo scambio di X con O)

Esempi

INPUT: 4         INPUT: 5       INPUT: 8              INPUT: 9
OO               OOOOO          XXXX                  XOX
OO                              XXXX                  OXO  
                                or rotated 90deg      XOX

Esempi non consentiti (non stessa riga o colonne di lunghezza)

BAD RESULT: 5a        BAD RESULT: 5b      BAD RESULT: 8
OOO                   OO                  OOO
OO                    OO                  OOO
                      O                   OO

Se possibile, fornisci un esempio online.

CJam, 16 (31-10-5)

Sono necessari due numeri interi di input, il primo è 0o 1per direzione e il secondo è il numero di Oo Xnella griglia.

Stampa un alternato Oe X.

:X"OX"*X<\Xmqi){(_X\%}g_X\/?/N*

Questo è solo il corpo della funzione, per provarlo aggiungi l~davanti al codice come:

l~:X"OX"*X<\Xmqi){(_X\%}g_X\/?/N*

e dare input come

0 10

per ottenere un output simile

OXOXO
XOXOX

o inserisci come

1 10

per

OX
OX
OX
OX
OX

Provalo online qui

Come funziona:

l~                                 "Put the two input integers to stack";
  :X                               "Assign the number of cells to X";
    "OX"*                          "Take string "OX" and repeat it X times";
         X<                        "Slice it to take only first X characters";
           \                       "Swap top two stack elements, now string is at bottom";
            Xmqi)                  "Take square root of X, ceil it and put on stack";
                 {(_X\%}g          "Keep decrementing until it is perfectly divisible by X";
                         _X\/      "Copy it, divide X by that and put it on stack";
                             ?     "Based on first input integer, take either of numbers";
                              /    "Divide the XOXO string that many times";
                               N*  "Join the string parts with a new line";

Esempio di esecuzione:

l~ed:X"OX"*edX<ed\edXmqi)ed{(_X\%}ged_edXed\ed/ed?ed/edN*ed

#INPUT:
1 10

#OUTPUT:
Stack: [1 10]

Stack: [1 "OXOXOXOXOXOXOXOXOXOX"]

Stack: [1 "OXOXOXOXOX"]

Stack: ["OXOXOXOXOX" 1]

Stack: ["OXOXOXOXOX" 1 4]

Stack: ["OXOXOXOXOX" 1 2]

Stack: ["OXOXOXOXOX" 1 2 2]

Stack: ["OXOXOXOXOX" 1 2 2 10]

Stack: ["OXOXOXOXOX" 1 2 10 2]

Stack: ["OXOXOXOXOX" 1 2 5]

Stack: ["OXOXOXOXOX" 2]

Stack: [["OX" "OX" "OX" "OX" "OX"]]

Stack: ["OX
OX
OX
OX
OX"]

OX
OX
OX
OX
OX

APL (36-5-10 = 21)

{'OX'⍴⍨⍺⌽⊃∆/⍨⍵=×/¨∆←∆[⍋|-/¨∆←,⍳2/⍵]}

L'argomento a sinistra è la rotazione, l'argomento a destra è la dimensione. Utilizza anche un modello semplice (alterna semplicemente "X" e "O").

      0{'OX'⍴⍨⍺⌽⊃∆/⍨⍵=×/¨∆←∆[⍋|-/¨∆←,⍳2/⍵]}¨4 5 8 9
 OX  OXOXO  OXOX  OXO 
 OX         OXOX  XOX 
                  OXO 
      1{'OX'⍴⍨⍺⌽⊃∆/⍨⍵=×/¨∆←∆[⍋|-/¨∆←,⍳2/⍵]}¨4 5 8 9
 OX  O  OX  OXO 
 OX  X  OX  XOX 
     O  OX  OXO 
     X  OX      
     O       

Spiegazione:

• ∆←,⍳2/⍵: Generare tutte le possibili coppie di numeri da 1a ⍵e conservare in ∆.
• ∆←∆[⍋|-/¨∆... ]: ordina ∆in ordine crescente nella differenza assoluta dei due numeri in ciascuna coppia e memorizza il risultato ∆.
• ⊃∆/⍨⍵=×/¨∆: per ogni coppia, moltiplicare i numeri insieme. Seleziona solo quelle coppie che si moltiplicano ⍵e prendi la prima che corrisponde (che è la "più quadrata" a causa dell'ordinamento).
• ⍺⌽: ruota l'elenco delle lunghezze (che ha 2 elementi) di ⍺.
• 'OX'⍴⍨: crea una matrice di quella dimensione e riempila con alternanza Oe X.

Haskell, 59 caratteri

r=replicate
f n=[r x$r y '0'|x<-[1..n],y<-[1..x],x*y==n]!!0

CJam, 25 22 21 (31 - 10)

Questo è un corpo di funzione. Se vuoi un programma completo, aggiungi ririin primo piano. Se vuoi usarlo come un blocco di codice, circondalo {}. Provalo su cjam.aditsu.net .

Prende l'input come due argomenti interi: l'interruttore per stabilire se il rettangolo è verticale (qualsiasi valore diverso da zero) o orizzontale (zero) e il numero di Os da utilizzare.

:Xmqi){(_X\%}g_X\/@{\}{}?'O*N+*

Spiegazione

:X "Assign the top item on the stack (the second input) to variable X";
mq "Take its square root";
i  "Convert to integer (round)";
)  "Increment it";

{  "Start code block";
  (  "Decrement";
  _X "Duplicate top item on stack; push X to the stack";
  \% "Swap top 2 items and take division remainder";
}g "Loop until top item on stack is 0; pop condition after checking it";

_X "Duplicate top item on stack; push X to the stack";
\/ "Swap top 2 items and divide";

"OMIT THIS BIT TO GET A 25-CHAR FUNCTION WITHOUT THE 10PT BONUS";
 @  "Rotate top 3 items on stack";
 {\}"Code block 1: swap top two items";
 {} "Code block 2: do nothing";
 ?  "If top item of stack is 0, run code block 1, otherwise run code block 2";

'O "Push the character O to the stack";
*  "Repeat it N times, where N is the second item from the top of the stack (O is first)";
N+ "Push a new line and concatenate it with the string on the top of the stack";
*  "Repeat the string N times";

JavaScript (E6) 84 (83 + 1) o 101 (116-10-5)

Pattern + rotazione (parametro f, 0 o 1) - bonus 15

F=(n,f)=>{
  for(r=x=0;y=n/++x|0,x<=y;)x*y-n?0:z=f?x:y;
  for(o='';n;)o+=(n--%z?'':(r^=1,c='\n'))+'OX'[r^(c^=1)];
  alert(o)
}

Nessun modello, nessuna rotazione - penalità 1

F=n=>{
  for(x=0;y=n/++x|0,x<=y;)x*y-n?0:z=y;
  alert(('O'.repeat(z)+'\n').repeat(n/z));
}

Test nella console FireFox / FireBug

F(30,0)

OXOXOX
XOXOXO
OXOXOX
XOXOXO
OXOXOX

F(30,1)

OXOXO
XOXOX
OXOXO
XOXOX
OXOXO
XOXOX

Python, 79 75 (nessun bonus)

I bonus sembrano complicati, quindi ecco una funzione Python piuttosto semplice:

def f(N):c=max(x*((x*x<=N)>N%x)for x in range(1,N+1));print(N/c*'O'+'\n')*c

Ruby, 74

f=->n{w=(1..n).min_by{|z|n%z>0?n:(n/z-n/(n/z))**2};$><<("X"*w+"\n")*(n/w)}

Spiegazione

• L'input viene preso come argomento per un lambda. Si aspetta un Integer.
• Controlla se n(l'input) è divisibile per ogni numero intero compreso tra 1 e n.
  • In tal caso, calcola la differenza tra lunghezza e larghezza.
  • In caso contrario, restituisce un numero grande ( n).
• Prendi le più piccole differenze di lunghezza e larghezza per assomigliare meglio a un quadrato.
• Utilizzare il String#*metodo (eccessivamente conciso) per "disegnare" il quadrato.

APL (Dyalog Unicode) , 30-15 = 15 byte ^SBCS

Infografica anonima lambda. Prende N come argomento destro e param come argomento sinistro. I rettangoli avranno strisce di X e O o saranno a scacchi.

{⍉⍣⍺⍴∘'XO'⊃∘c⌈.5×≢c←⍸⍵=∘.×⍨⍳⍵}

Provalo online!

{... } "dfn"; ⍺è l'argomento di sinistra (param), ⍵è l'argomento di destra ( N ):

 ⍳⍵ d ndices 1… N

 ∘.×⍨ tabella di moltiplicazione di quello

 ⍵= maschera dove N è uguale a quello

 ⍸ d ndices di valori reali nella maschera

 c← memorizzalo in c(per c andidates)

 ≢ conta i candidati

 .5× metà moltiplicata per quella

 ⌈ soffitto (arrotondato per eccesso)

 ⊃∘c scegli quell'elemento da c

 ⍴∘'XO' usalo per rimodellare ciclicamente "XO"

 ⍉⍣⍺ trasporre se param

05AB1E (legacy) , punteggio: 7 (22 byte - 15 bonus)

„OXI∍¹tï[D¹sÖ#<}äIiø}»

Provalo online o verifica alcuni altri casi di test .

Accetta Nprima gli input , quindi il valore booleano ( 0/ 1) indipendentemente dal fatto che debba ruotare o meno.

Utilizza la versione legacy di Python di 05AB1E poiché zip con un elenco di stringhe appiattisce e unisce implicitamente i caratteri, a differenza della nuova versione di riscrittura di Elisir di 05AB1E.

Spiegazione:

„OX         # Push string "OX"
   I∍       # Extend it to a size equal to the first input
            #  i.e. 9 → "OXOXOXOXO"
            #  i.e. 10 → "OXOXOXOXOX"
¹t          # Take the first input again, and square-root it
            #  i.e. 9 → 3.0
            #  i.e. 10 → 3.1622776601683795
  ï         # Then cast it to an integer, removing any decimal digits
            #  i.e. 3.0 → 3
            #  i.e. 3.1622776601683795 → 3
   [        # Start an infinite loop:
    D       #  Duplicate the integer
     ¹sÖ    #  Check if the first input is evenly divisible by that integer
            #   i.e. 9 and 3 → 1 (truthy)
            #   i.e. 10 and 3 → 0 (falsey)
        #   #  And if it is: stop the infinite loop
    <       #  If not: decrease the integer by 1
            #   i.e. 3 → 2
   }        # After the infinite loop:
ä           # Divide the string into that amount of equal sized parts
            #  i.e. "OXOXOXOXO" and 3 → ["OXO","XOX","OXO"]
            #  i.e. "OXOXOXOXOX" and 2 → ["OXOXO","XOXOX"]
 Ii }       # If the second input is truthy:
   ø        #  Zip/transpose; swapping rows/columns of the strings
            #   i.e. ["OXOXO","XOXOX"] → ["OX","XO","OX","XO","OX"]
»           # And finally join the strings in the array by newlines
            #  i.e. ["OXO","XOX","OXO"] → "OXO\nXOX\nOXO"
            #  i.e. ["OX","XO","OX","XO","OX"] → "OX\nXO\nOX\nXO\nOX"
            # (and output the result implicitly)

GolfScript 26 (41-10-5)

:x),1>{x\%!},.,2/=.x\/@{\}*'X'*n+*1>'O'\+

Si aspetta che due parametri siano nello stack:

• 0per normale o 1per trasposto
• il nvalore

Lo schema è che la tavola è piena di Xse l'angolo in alto a sinistra è un O. Inutile dire che questo modello viene mantenuto quando si traspone la scheda.

Demo: regolare , trasposto

Mathematica, 71 caratteri

f@n_:=#<>"\n"&/@Array["O"&,{#,n/#}&[#[[⌊Length@#/2⌋]]&@Divisors@n]]<>""

Petit Computer BASIC, 72 byte

INPUT N,S$FOR I=1TO SQR(N)IF N%I<1THEN M=I
NEXT
?(S$*M+" "*(32-M))*(N/M)

J , 32 byte - 15 = 17 byte

'XO'$~[|.](%,])i.@]{~0 i:~i.@]|]

Provalo online!

La rotazione è controllata da un flag 0/1 preso come argomento sinistro

Retina 0.8.2 , 66 byte + 1 byte penalità = 67

.+
$*X
((^|\3)(X(?(3)\3)))+(\3)*$
$3 $3$#4$*X
X(?=X* (X+))| X+
$1¶

Provalo online! Spiegazione:

.+
$*X

Converti l'input in una stringa di Xs.

((^|\3)(X(?(3)\3)))+(\3)*$

Il primo passaggio dell'acquisizione esterna corrisponde all'inizio della stringa, mentre nei passaggi successivi viene confrontato il valore precedente dell'acquisizione interna. La cattura interna viene quindi incrementata e abbinata. Il risultato è che la quantità di stringa consumata dalla cattura esterna è il quadrato della cattura interna, che pertanto non può superare la radice quadrata dell'input. Nel frattempo la ripetizione successiva assicura che la cattura interna sia un fattore della lunghezza della stringa.

$3 $3$#4$*X

Salvare il fattore scoperto e calcolare l'altro divisore aggiungendo il numero di ripetizioni successive.

X(?=X* (X+))| X+
$1¶

Riorganizza i fattori in un rettangolo.

Carbone , 33 byte - 10 - 5 = 18

Ｎθ≔⌊Φ⊕θ¬∨‹×ιιθ﹪θιηＥ÷θη⭆η§XO⁺ιλ¿Ｎ⟲

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

Ｎθ

Input N.

≔⌊Φ⊕θ¬∨‹×ιιθ﹪θιη

Prendi l'intervallo 0.. N, mantieni solo i numeri i cui quadrati non sono inferiori Ne dividi Ne prendi il minimo di quei numeri.

Ｅ÷θη⭆η§XO⁺ιλ

Utilizzare il fattore rilevato per generare un rettangolo della larghezza e dell'altezza appropriate utilizzando un modello a scacchiera. (Questo dovrebbe essere ＵＯη÷θηXO¶OXper un risparmio di 1 byte, ma al momento è difettoso.)

¿Ｎ⟲

Se il secondo input è diverso da zero, ruotare l'output. (Se la richiesta del secondo input è 0o 2è accettabile, ciò potrebbe essere ⟲Ｎper un salvataggio di 1 byte.)