Erstellen Sie eine Funktion oder ein Programm, mit dem ein Raster so nahe wie möglich an einem Quadrat liegt

• Sie erhalten eine Ganzzahl N als Eingabe, ganze Zahlen (1,2,3,25 usw.)
• Die Ausgabe muss ein perfektes rechteckiges Raster aus N Buchstaben sein, das so nah wie möglich an einem Quadrat liegt
• Das (Möchtegern-) Quadrat muss aus einem der vom Benutzer angegebenen Buchstaben O oder X bestehen

Punkte :

• Nur auf O oder X fest codiert: +1
• Ein Parameter (0/1, wahr / falsch, etwas Ähnliches) zum Drehen der Ausgabe (wie bei 5 oder 8): -10
• Entwerfen Sie das Quadrat (verwenden Sie sowohl O als auch X in einer Art Muster): -5

Ein Muster gilt als gültig, wenn es beide Zeichentypen enthält (wobei x / y-Achse> = 3 ist) und das Muster beim horizontalen oder vertikalen Spiegeln gleich bleibt (das Austauschen von Xs mit Os ist zulässig).

Beispiele

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

Beispiele, die nicht erlaubt sind (Zeilen oder Spalten nicht gleich lang)

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

Wenn möglich, geben Sie bitte ein Online-Beispiel an.

CJam, 16 (31 - 10 - 5)

Hierfür werden zwei Ganzzahlen eingegeben, von denen die erste 0oder die 1Richtung und die zweite die Anzahl Ooder Xdas Raster ist.

Es wird ein alternatives Ound gedruckt X.

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

Dies ist nur der Funktionskörper, um es auszuprobieren, fügen Sie l~vor dem Code Folgendes hinzu:

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

und geben Sie gerne wie

0 10

Ausgabe wie zu bekommen

OXOXO
XOXOX

oder Eingabe wie

1 10

zum

OX
OX
OX
OX
OX

Probieren Sie es hier online aus

Wie es funktioniert:

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

Beispiellauf:

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/⍵]}

Das linke Argument ist Rotation, das rechte Argument ist die Größe. Es wird auch ein einfaches Muster verwendet (es wechselt nur 'X' und '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       

Erläuterung:

• ∆←,⍳2/⍵: Generiere alle möglichen Zahlenpaare von 1bis ⍵und speichere in ∆.
• ∆←∆[⍋|-/¨∆... ]: sortiere ∆aufsteigend nach der absoluten Differenz der beiden Zahlen in jedem Paar und speichere das Ergebnis wieder in ∆.
• ⊃∆/⍨⍵=×/¨∆: Multiplizieren Sie für jedes Paar die Zahlen miteinander. Wählen Sie nur die Paare aus, mit denen multipliziert wird ⍵, und nehmen Sie das erste, das übereinstimmt (was aufgrund der Sortierung das "quadratischste" ist).
• ⍺⌽: Drehen Sie die Liste der Längen (die 2 Elemente enthält) um ⍺.
• 'OX'⍴⍨: Erstellen Sie eine Matrix dieser Größe und füllen Sie sie mit abwechselndem Ound X.

Haskell, 59 Zeichen

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)

Dies ist ein Funktionskörper. Wenn Sie ein vollständiges Programm wünschen, fügen Sie riries der Vorderseite hinzu. Wenn Sie es als Codeblock verwenden möchten, umgeben Sie es in {}. Testen Sie es auf cjam.aditsu.net .

Die Eingabe erfolgt als zwei ganzzahlige Argumente: der Schalter, ob das Rechteck vertikal (ein Wert ungleich Null) oder horizontal (Null) ist, und die Anzahl der Ozu verwendenden s.

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

Erläuterung

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

Muster + Drehung (Parameter f, 0 oder 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)
}

Kein Muster, keine Rotation - Strafe 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 In FireFox / Firebug - Konsole

F(30,0)

OXOXOX
XOXOXO
OXOXOX
XOXOXO
OXOXOX

F(30,1)

OXOXO
XOXOX
OXOXO
XOXOX
OXOXO
XOXOX

Python, 79 75 (keine Boni)

Die Boni scheinen schwierig zu sein, daher hier eine ziemlich einfache Python-Funktion:

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)}

Erläuterung

• Die Eingabe wird als Argument für ein Lambda verwendet. Es erwartet eine Integer.
• Überprüfen Sie, ob n(die Eingabe) durch jede Ganzzahl von 1 bis teilbar ist n.
  • Wenn dies der Fall ist, berechnen Sie die Differenz zwischen Länge und Breite.
  • Ist dies nicht der Fall, geben Sie eine große Zahl ( n) zurück.
• Nehmen Sie den kleinsten Längen- und Breitenunterschied, um einem Quadrat am besten zu ähneln.
• Verwenden Sie die (zu präzise) String#*Methode, um das Quadrat zu "zeichnen".

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

Anonymes Infix Lambda. Nimmt N als rechtes Argument und param als linkes Argument. Rechtecke haben entweder Streifen von X und O oder sind kariert.

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

Probieren Sie es online aus!

{… } "Dfn"; ⍺ist linkes Argument (param), ⍵ist rechtes Argument ( N ):

 ⍳⍵ ices ndices 1… N.

 ∘.×⍨ Multiplikationstabelle davon

 ⍵= Maske, bei der N gleich ist

 ⍸ true Indizes der wahren Werte in der Maske

 c← Speichern Sie das in c(für c andidates)

 ≢ zählen die Kandidaten

 .5× eine Hälfte multipliziert damit

 ⌈ Decke (aufgerundet)

 ⊃∘c Wählen Sie dieses Element aus c

 ⍴∘'XO' Verwenden Sie dies, um "XO" zyklisch umzuformen.

 ⍉⍣⍺ transponieren, wenn param

05AB1E (Legacy) , Punktzahl: 7 (22 Bytes - 15 Bonus)

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

Probieren Sie es online aus oder überprüfen Sie weitere Testfälle .

Nimmt zuerst die Eingaben Nund dann den Booleschen Wert ( 0/ 1), ob er sich drehen soll oder nicht.

Verwendet die Python-Legacy-Version von 05AB1E, da zip mit einer String-Liste die Zeichen implizit abflacht und verbindet, im Gegensatz zur neueren Elixir-Rewrite-Version von 05AB1E.

Erläuterung:

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

Erwartet zwei Parameter auf dem Stapel:

• 0für normal oder 1für transponiert
• der nWert

Das Muster ist, dass das Brett voller Xs ist und die obere linke Ecke ein ist O. Es ist unnötig zu erwähnen, dass dieses Muster beim Transponieren der Platine beibehalten wird.

Demo: regelmäßig , transponiert

Mathematica, 71 Zeichen

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

Petit Computer BASIC, 72 Bytes

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

J , 32 Bytes - 15 = 17 Bytes

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

Probieren Sie es online aus!

Die Drehung wird durch ein 0/1-Flag gesteuert, das als linkes Argument verwendet wird

Retina 0,8,2 , 66 Bytes + 1 Byte Strafe = 67

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

Probieren Sie es online aus! Erläuterung:

.+
$*X

Konvertieren Sie die Eingabe in eine Zeichenfolge von Xs.

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

Der erste Durchgang der äußeren Erfassung entspricht dem Anfang der Zeichenfolge, während bei nachfolgenden Durchläufen der vorherige Wert der inneren Erfassung übereinstimmt. Die innere Erfassung wird dann erhöht und abgeglichen. Das Ergebnis davon ist, dass die Menge an Zeichenfolge, die von der äußeren Erfassung verbraucht wird, das Quadrat der inneren Erfassung ist, das daher die Quadratwurzel der Eingabe nicht überschreiten kann. Währenddessen stellt die nachfolgende Wiederholung sicher, dass die innere Erfassung ein Faktor für die Länge der Zeichenfolge ist.

$3 $3$#4$*X

Speichern Sie den erkannten Faktor und berechnen Sie den anderen Divisor, indem Sie die Anzahl der nachfolgenden Wiederholungen addieren.

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

Ordnen Sie die Faktoren in einem Rechteck neu an.

Holzkohle , 33 Bytes - 10 - 5 = 18

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Erläuterung:

Ｎθ

Eingabe N.

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

Nehmen Sie den Bereich 0.. N, behalten Sie nur die Zahlen, deren Quadrate nicht kleiner als Nund dividiert sind N, und nehmen Sie das Minimum dieser Zahlen.

Ｅ÷θη⭆η§XO⁺ιλ

Verwenden Sie den erkannten Faktor, um ein Rechteck mit der entsprechenden Breite und Höhe mithilfe eines Schachbrettmusters auszugeben. (Dies sollte ＵＯη÷θηXO¶OXfür eine 1-Byte-Speicherung sein, aber das ist momentan fehlerhaft.)

¿Ｎ⟲

Wenn der zweite Eingang ungleich Null ist, drehen Sie den Ausgang. (Wenn die zweite Eingabe akzeptabel sein muss 0oder 2akzeptabel ist, kann dies ⟲Ｎfür eine 1-Byte-Speicherung sein.)