Créer une fonction ou un programme qui rend une grille aussi proche que possible d'un carré

• Vous recevrez un entier N en entrée, des nombres entiers (1,2,3,25, etc.)
• La sortie doit être une grille rectangulaire parfaite de N lettres aussi proche que possible d'un carré
• Le carré (wannabe) doit être composé de l'une des lettres O ou X spécifiées par l'utilisateur

Points :

• Codé en dur à seulement O ou X: +1
• Un paramètre (0/1, vrai / faux, quelque chose de similaire) pour faire pivoter la sortie (comme avec 5 ou 8): -10
• Concevez le carré (utilisez à la fois O et X dans une sorte de motif): -5

Un modèle est considéré comme valide s'il contient les deux types de caractères (où l'axe x / y> = 3) et le modèle reste le même lorsqu'il est inversé horizontalement ou verticalement (l'échange de X avec Os est autorisé)

Exemples

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

Exemples non autorisés (pas la même longueur de ligne ou de colonnes)

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

Si possible, veuillez fournir un exemple en ligne.

CJam, 16 (31 - 10 - 5)

Cela prend deux entiers sont entrés, le premier étant 0ou 1pour la direction et le second étant le nombre de Oou Xdans la grille.

Il imprime un autre Oet X.

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

Ceci est juste le corps de la fonction, pour l'essayer, ajoutez-le l~devant le code comme:

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

et donner une entrée comme

0 10

pour obtenir une sortie comme

OXOXO
XOXOX

ou entrez comme

1 10

pour

OX
OX
OX
OX
OX

Essayez-le en ligne ici

Comment ça fonctionne:

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";

Exemple d'exécution:

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'argument de gauche est la rotation, l'argument de droite est la taille. Il utilise également un modèle simple (il alterne simplement «X» et «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       

Explication:

• ∆←,⍳2/⍵: Générer toutes les paires possibles de nombres d' 1à ⍵et de stocker dans ∆.
• ∆←∆[⍋|-/¨∆... ]: trier ∆par ordre croissant dans la différence absolue des deux nombres de chaque paire et stocker le résultat dans ∆.
• ⊃∆/⍨⍵=×/¨∆: pour chaque paire, multipliez les nombres ensemble. Sélectionnez uniquement les paires qui se multiplient ⍵et prenez la première qui correspond (qui est la «plus carrée» en raison du tri).
• ⍺⌽: faire pivoter la liste des longueurs (qui comporte 2 éléments) de ⍺.
• 'OX'⍴⍨: créez une matrice de cette taille et remplissez-la d'alternance Oet X.

Haskell, 59 caractères

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)

Il s'agit d'un corps de fonction. Si vous voulez un programme complet, ajoutez-le ririà l'avant. Si vous souhaitez l'utiliser comme bloc de code, entourez-le {}. Testez-le sur cjam.aditsu.net .

Il prend l'entrée comme deux arguments entiers: le commutateur pour savoir si le rectangle est vertical (toute valeur non nulle) ou horizontal (zéro), et le nombre de Os à utiliser.

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

Explication

: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) ou 101 (116-10-5)

Motif + rotation (paramètre f, 0 ou 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)
}

Aucun modèle, aucune rotation - pénalité 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 dans la console FireFox / FireBug

F(30,0)

OXOXOX
XOXOXO
OXOXOX
XOXOXO
OXOXOX

F(30,1)

OXOXO
XOXOX
OXOXO
XOXOX
OXOXO
XOXOX

Python, 79 75 (pas de bonus)

Les bonus semblent difficiles, voici donc une fonction Python assez simple:

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

Rubis, 74

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

Explication

• L'entrée est considérée comme un argument d'un lambda. Il attend un Integer.
• Vérifiez si n(l'entrée) est divisible par chaque entier de 1 à n.
  • Si c'est le cas, calculez la différence entre la longueur et la largeur.
  • Si ce n'est pas le cas, retournez un grand nombre ( n).
• Prenez la plus petite des différences longueur-largeur pour mieux ressembler à un carré.
• Utilisez la String#*méthode (trop concise) pour "dessiner" le carré.

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

Infixe anonyme lambda. Prend N comme argument de droite et param comme argument de gauche. Les rectangles auront soit des rayures de X et O, soit seront quadrillés.

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

Essayez-le en ligne!

{… } "Dfn"; ⍺est l'argument gauche (param), ⍵est l'argument droit ( N ):

 ⍳⍵ ɩ ndices 1… N

 ∘.×⍨ table de multiplication de cette

 ⍵= masque où N est égal à celui

 ⍸ ɩ ndices de vraies valeurs dans le masque

 c← stocker cela dans c(pour c etidates)

 ≢ compter les candidats

 .5× une moitié multipliée par celle

 ⌈ plafond (arrondi)

 ⊃∘c choisir cet élément c

 ⍴∘'XO' utiliser cela pour remodeler cycliquement "XO"

 ⍉⍣⍺ transposer si param

05AB1E (legacy) , score: 7 (22 octets - 15 bonus)

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

Essayez-le en ligne ou vérifiez d'autres cas de test .

Prend d'abord les entrées N, puis le booléen ( 0/ 1) s'il doit tourner ou non.

Utilise la version héritée Python de 05AB1E car zip avec une liste de chaînes aplatit et joint implicitement les caractères, contrairement à la nouvelle version de réécriture Elixir de 05AB1E.

Explication:

„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'\+

Attend que deux paramètres soient sur la pile:

• 0pour normal ou 1pour transposé
• la nvaleur

Le motif est que la planche est pleine de Xs et le coin supérieur gauche est un O. Inutile de dire que ce motif est maintenu lors de la transposition de la planche.

Démo: régulière , transposée

Mathematica, 71 caractères

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

Petit ordinateur BASIC, 72 octets

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

J , 32 octets - 15 = 17 octets

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

Essayez-le en ligne!

La rotation est contrôlée par un drapeau 0/1 pris comme argument de gauche

Retina 0.8.2 , 66 octets + 1 octet de pénalité = 67

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

Essayez-le en ligne! Explication:

.+
$*X

Convertissez l'entrée en une chaîne de Xs.

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

La première passe de la capture externe correspond au début de la chaîne tandis que lors des passes suivantes, la valeur précédente de la capture interne est mise en correspondance. La capture intérieure est ensuite incrémentée et mise en correspondance. Le résultat est que la quantité de chaîne consommée par la capture externe est le carré de la capture interne, qui ne peut donc pas dépasser la racine carrée de l'entrée. Pendant ce temps, la répétition suivante garantit que la capture intérieure est un facteur de la longueur de la chaîne.

$3 $3$#4$*X

Enregistrez le facteur découvert et calculez l'autre diviseur en ajoutant le nombre de répétitions suivantes.

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

Réorganisez les facteurs dans un rectangle.

Fusain , 33 octets - 10 - 5 = 18

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｎθ

Entrée N.

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

Prenez la plage 0.. N, ne gardez que les nombres dont les carrés ne sont pas inférieurs à Net divisez N, et prenez le minimum de ces nombres.

Ｅ÷θη⭆η§XO⁺ιλ

Utilisez le facteur découvert pour produire un rectangle de la largeur et de la hauteur appropriées à l'aide d'un motif de damier. (Cela devrait être ＵＯη÷θηXO¶OXpour une économie d'un octet, mais c'est un bug en ce moment.)

¿Ｎ⟲

Si la deuxième entrée est différente de zéro, faites pivoter la sortie. (Si la deuxième entrée doit être 0ou 2est acceptable, cela peut être ⟲Ｎpour une économie de 1 octet.)