introduzione

Potresti conoscere e amare il tuo normale cerchio unitario. Ma i matematici sono pazzi e quindi hanno sottratto il concetto a qualsiasi punto che soddisfi x*x+y*y=1. Poiché anche i Cryptographers ¹ sono strani, amano i campi finiti e talvolta gli anelli finiti (non è come se avessero molta scelta), quindi uniamo questo!

La sfida

Ingresso

Un numero intero positivo maggiore di uno nella codifica preferita. Chiamiamo questo numero n.

Produzione

Verrà emessa la "immagine" (che consiste di n volte n caratteri) del cerchio unitario del modulo intero di input come ASCII-Art usando "X" (X maiuscola) e "" (uno spazio). Sono consentiti spazi finali e newline.

Più dettagli

Devi estendere un sistema di coordinate da in basso a sinistra a in alto a destra. Ogni volta che un punto soddisfa l'equazione del cerchio, posiziona una X nella posizione, altrimenti posiziona uno spazio.

La condizione per un punto da considerare parte del bordo cerchio è:
mod(x*x+y*y,n)==1.

Ecco una breve illustrazione del sistema di coordinate:

(0,4)(1,4)(2,4)(3,4)(4,4)
(0,3)(1,3)(2,3)(3,3)(4,3)
(0,2)(1,2)(2,2)(3,2)(4,2)
(0,1)(1,1)(2,1)(3,1)(4,1)
(0,0)(1,0)(2,0)(3,0)(4,0)

Se ti aiuta, puoi anche invertire la direzione di uno qualsiasi degli assi, ma gli esempi assumono questo orientamento.

Chi vince?

Questo è code-golf quindi vince il codice più corto in byte! Sono ammessi solo i metodi I / O predefiniti e sono vietate tutte le scappatoie standard.

Esempi

Ingresso: 2

X 
 X

Ingresso: 3

X  
X  
 XX

Ingresso: 5

X    


X    
 X  X

Ingresso: 7

Ingresso: 11

Ingresso: 42

X                                         
         X                       X        


            X                 X           
       X                           X      
      X                             X     
                     X                    
  X             X         X             X 


     X             X   X             X    
X                                         
               X           X              
              X             X             
         X                       X        


            X                 X           
                     X                    
        X           X X           X       
                     X                    
            X                 X           


         X                       X        
              X             X             
               X           X              
X                                         
     X             X   X             X    


  X             X         X             X 
                     X                    
      X                             X     
       X                           X      
            X                 X           


         X                       X        
X                                         
 X           X               X           X

¹_{Ti suggerisco di dare un'occhiata al mio profilo se ti stai chiedendo qui.}

— SEJPM
fonte

Sembra molto meglio se usi il dominio [0, n] secondo me. Ecco un esempio con l'ingresso 42.

— R. Kap

Per "I / O standard" intendi i metodi I / O predefiniti o intendi STDIN / STDOUT effettivi? Sto assumendo il primo, ma penso che qualcuno di seguito lo abbia interpretato come il secondo.

— Ørjan Johansen,

@ ØrjanJohansen davvero il primo.

— SEJPM

Sono consentite le nuove righe precedenti?

— Fergusq,

@fergusq come altererebbero (drasticamente) la figura di output in modo visibile, no.

— SEJPM

6

Utilità Bash + GNU, 59

x={0..$[$1-1]}d*
eval echo $x$x+$1%1-0r^56*32+P|dc|fold -$1

Input nfornito come parametro della riga di comando. L'asse y è invertito.

Provalo online .

— Trauma digitale
fonte

4

Ottava , 45 44 byte

@(n)[(mod((x=(0:n-1).^2)+x',n)==1)*56+32,'']

Provalo online!

— flawr
fonte

Questo funziona anche: @(n)[(mod((x=(0:n-1).^2)+x',n)==1)*88,'']. In alcuni sistemi Octave tratta il personaggio 0come uno spazio

— Luis Mendo,

3

Haskell , 68 byte

f n|r<-[0..n-1]=unlines[[last$' ':['X'|mod(x*x+y*y)n==1]|y<-r]|x<-r]

Provalo online! L'asse y è invertito. Utilizzo: f 42restituisce una stringa delimitata da nuova riga.

Questa è una comprensione di elenco nidificata in cui entrambi xe ysono tratti dall'intervallo [0..n-1]. last$' ':['X'|mod(x*x+y*y)n==1]è una forma più breve di if mod(x*x+y*y)n==1 then 'X' else ' '. La comprensione dell'elenco restituisce un elenco di stringhe che viene trasformato in una nuova riga separata da una nuova riga unlines.

— Laikoni
fonte

3

Mathematica, 56 48 byte

Modifica: grazie a Greg Martin e Martin Ender per aver salvato 8 byte.

Grid@Array[If[Mod[#^2+#2^2,x]==1,X]&,{x=#,#},0]&

Soluzione originale:

Grid@Table[If[Tr[{i-1,j-1}^2]~Mod~#==1,X,],{i,#},{j,#}]&

— ngenisis
fonte

Osservazione divertente: non è necessario la virgola dopo X:)

— Greg Martin

1

Penso che tu sia meglio con Arraye Norm:Grid@Array[If[Mod[Norm@{##}^2,x]==1,X]&,{x=#,#},0]&

— Martin Ender

2

Pensare ancora ... #^2+#2^2è il più breve.

— Martin Ender,

@GregMartin Quindi se il primo argomento Ifnon è né Trueo False, è necessario il quarto argomento o rimane non valutato, ma If[False,_]restituisce Null. Strano.

— ngenisis,

@MartinEnder inizialmente ho provato Arrayma non ho pensato di impostare l'argomento su una variabile.

— ngenisi,

2

CJam , 23 byte

ri:X,2f#_ff{+X%(S'X?}N*

Provalo online!

ri:X    e# Read input, convert to integer, store in X.
,       e# Turn into range [0 1 ... X-1].
2f#     e# Square each value in the range.
_ff{    e# 2D map over all pairs from that list.
  +     e#   Add the two values in the current pair.
  X%    e#   Take the sum modulo X.
  (     e#   Decrement, so that x^2+y^2==1 becomes 0 (falsy) and everything
        e#   else becomes truthy.
  S'X?  e#   Select space of 'X' accordingly.
}
N*      e# Join rows with linefeeds.

— Martin Ender
fonte

2

JavaScript (ES6), 81 byte

f=
n=>[...Array(n)].map((_,x,a)=>a.map((_,y)=>(x*x+y*y)%n-1?` `:`X`).join``).join`
`

<input type=number oninput=o.textContent=f(+this.value)><pre id=o>

Espandi frammento

L'asse Y è il contrario dell'OP.

— Neil
fonte

2

Röda , 74 byte

f n{seq n-1,0|{|y|seq 0,n-1|{|x|["X"]if[(x^2+y^2)%n=1]else[" "]}_;["
"]}_}

Provalo online!

Ungolfed:

function f(n) {
    seq(n-1, 0) | for y do
        seq(0, n-1) | for x do
            if [ (x^2 + y^2) % n = 1 ] do
                push("X")
            else
                push(" ")
            done
        done
        print("")
    done
}

— fergusq
fonte

2

Python 3 , 87 83 byte

lambda n:"\n".join("".join(" X"[(y*y+x*x)%n==1]for x in range(n))for y in range(n))

Provalo online!

L'asse y è invertito

— OVS
fonte

2

Gelatina , 14 13 byte

R²+þ`%=1ị⁾X Y

L'asse x è invertito.

Provalo online!

Come funziona

R²+þ`%=1ị⁾X Y  Main link. Argument: n

R              Range; yield [1, ..., n].
 ²             Square; yield [1², ..., n²].
  +þ`          Self table addition; compute x+y for all x and y in [1², ..., n²],
               grouping by the values of y.
     %         Take all sums modulo n.
      =1       Compare them with 1, yielding 1 or 0.
        ị⁾X    Index into "X ".
            Y  Separate by linefeeds.

— Dennis
fonte

1

dc , 79 byte

?dsRsQ[88P]sl[32P]sH[0sM[lM2^lR2^+lQ%d1=l1!=HlM1+dsMlQ>c]dscx10PlR1-dsR0<S]dsSx

L' yasse è invertito mentre l' xasse no.

Provalo online!

— R. Kap
fonte

1

MATL , 13 byte

:qU&+G\1=88*c

L'origine è in alto a sinistra. Quindi l'output viene capovolto rispetto agli esempi della sfida.

Prova a MATL online!

Spiegazione

:      % Input n implicitly. Push [1 2 ... n]
q      % Subtract one (element-wise)
U      % Square (element-wise)
&+     % Matrix of pairwise sums
G      % Push n
\      % Modulo
1=     % Equal to 1? (element-wise)
88*    % Multiply by 88 (ASCII code of 'X')
c      % Convert to char. Char 0 will be displayed as a space
       % Display implicitly

— Luis Mendo
fonte

1

Python 3 , ( 102 98 95 byte)

asse y invertito

n=int(input());r=range(n);p=print
for i in r:
 for j in r:p(end=' 'if(i*i+j*j)%n-1else'X')
 p()

Provalo online!

salvato 4 byte: omessa variabile c in c = '' if (i i + j j)% n-1else'X '
salvato 3 byte: grazie a ovs (istruzione di stampa modificata)

— officialaimm
fonte

1

p(end=' 'if(i*i+j*j)%n-1else'X')per 95 byte

— ovs

1

Lithp , 125 byte

#N::((join(map(seq(- N 1)0)(scope #Y::((join(map(seq 0(- N 1))(scope #X::
((?(== 1(@(+(* X X)(* Y Y))N))"X" " "))))""))))"\n")

Linebreak per leggibilità.

Provalo online!

Non il più corto. Penso di aver bisogno di una sorta di modulo abbreviato. Vedere il collegamento Provalo online per ulteriori spiegazioni, versione non modificata e alcuni test. Per i migliori risultati, espandi la finestra di output per vedere di più.

— Andrakis
fonte

1

Python 3 , 82 byte

f=lambda n,k=0:k<n>f(n,k+1)!=print(''.join(' X'[(k*k+j*j)%n==1]for j in range(n)))

Provalo online!

— Dennis
fonte

1

GNU APL , 41 caratteri, 59 byte

Legge un numero intero e visualizza il cerchio.

N←⎕◊⌽{(⍵+1)⊃' ' 'X'}¨{1=(N|(+/⍵*2))}¨⍳N N

Ungolfed

N←⎕
⌽                           ⍝ flip the X axis so 0,0 is bottom left
{
    (⍵+1) ⊃ ' ' 'X'         ⍝ substitute space for 0, X for 1
} ¨ {
    1=(N|(+/⍵*2))           ⍝ mod(x*x+y*y, 1)==1
} ¨ ⍳N N                    ⍝ generate an NxN grid of coordinates

— Megashroom
fonte

0

Haskell, 115 byte

n#(a,b)|mod(a*a+b*b)n==1='X'|1>0=' '
m n=map(n#)<$>zipWith(zipWith(,))(replicate n[0..n-1])(replicate n<$>[0..n-1])

L'asse y è invertito.

Provalo online!

Tutte quelle parentesi mi danno un po 'fastidio ...

Spiegazione

n#(a,b)|mod(a*a+b*b)n==1='X'|1>0=' '
n#(a,b)                                 --Operator #, takes a number n and a tuple (a,b)
       |mod(a*a+b*b)n==1                --Test if the mod equals 1
                        ='X'            --If so, return 'X'
                            |1>0=' '    --Otherwise, return ' '

m n=map(n#)<$>zipWith(zipWith(,))(replicate n[0..n-1])(replicate n<$>[0..n-1])
m n=                                                                           --Make a new function m with argument n
                                 (replicate n[0..n-1])                         --Make a list of [[0,1,2,3..n-1],[0,1,2,3..n-1],(n times)]
                                                      (replicate n<$>[0..n-1]) --Make a list of [[0,0,0(n times)],[1,1,1(n times)]..[n-1,n-1,n-1(n times)]
              zipWith(zipWith(,))                                              --Combine them into a list of list of tuples
    map(n#)<$>                                                                 --Apply the # operator to every tuple in the list with the argument n

— Nome visualizzato generico
fonte

Puoi sostituire l'ultimo mapcon un <$>, giusto?

— k_g

A meno che non stia fraintendendo le regole della domanda, non penso che tu abbia bisogno di tutto ciò che I / O - il golf I / O su PPCG ha impostazioni predefinite speciali per consentire a quante più lingue possibile di partecipare. Ad esempio, la funzione principale può accettare un argomento intero e restituire una stringa.

— Ørjan Johansen

@k_g si grazie

— Nome visualizzato generico

@ ØrjanJohansen debitamente annotato :)

— Nome visualizzato generico

0

J , 20 byte

' x'{~1=[|+/~@:*:@i.

Provalo online!

— Perdente Suora
fonte

0

GolfScript , 34 byte

~:c,{.*}%:a{:b;a{b+c%1=' x'=}%}%n*

Provalo online!

Non mi piace davvero usare le variabili ...

— Perdente Suora
fonte

Disegnami il (strano) cerchio unitario!

introduzione

La sfida

Ingresso

Produzione

Più dettagli

Chi vince?

Esempi

Utilità Bash + GNU, 59

Ottava , 45 44 byte

Haskell , 68 byte

Mathematica, 56 48 byte

Soluzione originale:

CJam , 23 byte

JavaScript (ES6), 81 byte

Röda , 74 byte

Python 3 , 87 83 byte

Gelatina , 14 13 byte

Come funziona

dc , 79 byte

MATL , 13 byte

Spiegazione

Python 3 , ( 102 98 95 byte)

asse y invertito

Lithp , 125 byte

Python 3 , 82 byte

GNU APL , 41 caratteri, 59 byte

Ungolfed

Haskell, 115 byte

Spiegazione

J , 20 byte

GolfScript , 34 byte