Faire x sans y

52

Habituellement, il est dit que "Faire X sans Y" peut être un piège pour les débutants qui écrivent des défis ( source ). Cependant, je suis arrogant et pense que je peux certainement faire un X sans Ys. Au hasard. Oh oui, ce sera bien.

Défi: Étant donné un entier impair nsupérieur ou égal à 1, affiche un ex de côté ncomposé de caractères ascii imprimables au hasard, sans "y" et "Y", ainsi que de l’espace. Tous les personnages autorisés doivent avoir une chance non nulle de se produire, mais pas nécessairement uniforme. Ceci est un donc le code le plus court en octets gagne. Vous devez cependant randomiser chaque caractère - c'est-à-dire que les jambes de force de l'ex ne doivent pas être égales, sauf si c'est par hasard.

Les caractères à paraître

!#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXZ[\]^_`abcdefghijklmnopqrstuvwxz{|}~"

Construire l'ex

Longueur du côté 1:

x

Longueur du côté 3:

x x
 x
x x

Longueur du côté 5:

x   x
 x x
  x
 x x
x   x

etc.

Exemple de sorties

input
output
empty line

3
h 2
 ^
9 5

1
:

5
D   1
 W z
  W
 q j
W   1

Exemple d'implémentation

Vous n'avez pas besoin de gérer des entrées non valides.

Conor O'Brien
la source
Quels personnages exactement doivent être éligibles?
xnor
@xnor Personnages de !à ~sans yetY
Conor O'Brien
@ LegionMammal978 Non, car les caractères autres que Y incluent yet .
Leaky Nun
7
Hmm .. random ...
NonlinearFruit
14
Attendez!? Nous sommes autorisés à utiliser "Y" et "y" dans le notre code?
Adám

Réponses:

3

Pyth, 28 27 26 25 octets

jmuXGHO-rF "! ~" "Yy" {, d-tQd *; Q 
VQuXGHO-rF "! ~" "Yy" {, N-tQN * d 
VQuXGHO-r \! \ ~ "Yy" {, N-tQN *ré
VQuXGHO-r \! \ ~ "Yy", N-tQN * d

Suite de tests.

Fuite, nonne
la source
5
Je suis sûr que cela ne produira jamais le ~personnage, car la gamme ne l'inclut pas. Vous pouvez résoudre ce problème en remplaçant ~le code par le caractère DEL littéral.
FryAmTheEggman
10

Ruby, 102 octets

Array#samplene répétez pas l'échantillonnage à partir du jeu de caractères, mais c'est correct car la répartition des caractères ne doit pas nécessairement être parfaitement uniforme! Fonction récursive, retourne un tableau de lignes.

Essayez-le en ligne!

f=->l{w,x,y,z=([*?!..?~]-%w"y Y").sample 4
l<2?[w]:[w+(s=' '*(l-2))+x,*f[l-2].map{|e|" #{e} "},y+s+z]}
Valeur d'encre
la source
7

En fait, 62 octets

"!⌂"♂┘ix♂c"Yy"@-╗½≈u;r2@∙`i=`M╪k`;dXR@+`M;dXR@+`"╜J' aI"£MΣ`Mi

C'est l'un des programmes les plus longs que j'ai jamais écrit.

Essayez-le en ligne!

Explication:

Partie 1 : configurer la liste des personnages

"!⌂"♂┘ix♂c"Yy"@-
"!⌂"              push the string "!⌂"
    ♂┘            CP437 ordinal of each character ([21, 127])
      ix          range(21, 127)
        ♂c        character at each ordinal (list of printable ASCII characters)
          "Yy"@-  set difference with ["Y", "y"] (printable ASCII except "Y" and "y")

Essayez-le en ligne!

Partie 2 : construction du tableau booléen pour un X

½≈u;r2@∙`i=`M╪k`;dXR@+`M;dXR@+
½≈u;                            two copies of int(input/2)+1
    r                           range
     2@∙                        Cartesian product with itself
        `i=`M                   for each sublist: push 1 if both elements are equal, else 0
             ╪k                 split into int(input/2)+1-length chunks
                                (at this point, we have one quarter of the X)
               `;dXR@+`M        mirror each sublist (one half of the X)
                        ;dXR@+  mirror the entire list (the whole X)

Essayez-le en ligne!

Partie 3 : choisir des caractères aléatoires

`"╜J' aI"£MΣ`Mi
`"╜J' aI"£MΣ`M   for each row:
 "╜J' aI"£M        for each column:
  ╜J                 push a random value from the character list
    '                push a space
      a              invert the stack
       I             take the character if the value is 1, else take the space
           Σ       concatenate the strings
              i  flatten the list and let implicit output take care of the rest

Essayez-le en ligne!

Mego
la source
1
"Visualize bit weaving" était de 69 octets ;-)
AdmBorkBork
6

Mathematica, 146 octets

a:=RandomChoice[33~CharacterRange~126~Complement~{"Y","y"}];StringRiffle[Normal@SparseArray[{{b_, b_}:>a,{b_,c_}/;c-1==#-b:>a},{#,#}," "],"
",""]&

Fonction anonyme. Prend un nombre en entrée et retourne une chaîne en sortie.

LegionMammal978
la source
6

Python 2, 171 octets

from random import*
def x(n):
 w=range(-n/2+1,n/2+1)
 for i in w:
  o=''
  for j in w:c=randint(33,124);c+=(c>88)+(c>119);c=[c,32][bool(i^j and i^-j)];o+=chr(c)
  print o

Garanti de choisir des caractères aléatoires avec une probabilité uniforme.

Essayez-le ici: lien ideone

EDIT: Merci à Morgan Thrapp pour les corrections.

ossifrage délirant
la source
from random import*enregistre 2 octets. Vous pouvez également joindre les deux premières lignes de la jboucle avec un point-virgule pour enregistrer des octets. (Aussi, je crois Zet {ai plus de chance de survenir que certaines autres lettres, cela ne compte pas pour la question.)
FryAmTheEggman
Vous pouvez descendre à 165 avec un couple de petites modifications mothereff.in/…
Morgan Thrapp
2
En fait, votre sortie est fausse pour tous les cas de test. Vous faites chaque jambe égale à n au lieu de la taille totale du côté.
Morgan Thrapp
@ MorganThrapp Ah, vous avez raison. Je vais arranger ça
ossifrage
4 octets: bool(i^j and i^-j)->i not in(j,-j)
Jonathan Allan
6

Python, 142 139 135 octets

Ceci est une implémentation simple qui crée le carré caractère par caractère. Si le caractère est en diagonale : utilisez un caractère aléatoire, sinon : utilisez un espace. Ceci utilise également une substitution regex et random int pour générer des non Ycaractères:

import re,random
lambda x:''.join('\n'*(i%x<1)+re.sub("y|Y","t",chr(random.randint(33,126))+' ')[i%x!=i/x!=x-i%x-1]for i in range(x*x))

Explication [ancien]

"\n".join( ... for i in range(x)) # Create 'x' lines 
''.join( ... for j in range(x))   # Create 'x' chars on each line
(...)[j!=i!=x-j-1]                # Not on diagonals? 2nd char in "? "; Else, choose the 1st
j!=i                              # Not on downward diagonal
i!=x-j-1                          # Not on upward diagonal
re.sub("y|Y","t", ... )           # Replace y or Y for t
chr(random.randint(33,126))+' '   # Random char + a space

Mise à jour

  • -4 [16-07-30] Nouvelle ligne conditionnelle abrégée
  • -3 [16-07-30] remplacé par single for-loop
  • -6 [16-07-29] Échangé si déclaration pour op. Ternaire. Merci à @RootTwo
  • -11 [16-07-27] Suppression de crochets / espaces supplémentaires et inversion de l'instruction if
  • -49 [16-07-27] Absorded @ la méthode de squeamishossifrage en créant le carré, étape par étape, merci!
  • -10 [16-07-27] Raccourcissez le contenu aléatoire des caractères lambda + mathématiques de @ ConorO'Brien
  • -22 [16-07-26] Squeaze dans un golf lambda + misc
  • -6 [16-07-26] import*- Merci à @KevinLau
Fruit non linéaire
la source
1
randintest probablement plus court pour vos besoins, plus from random import*. En outre, supprimez une partie de cet espace blanc inutile.
Valeur d'encre
2
[i,33][i in(89,121)]fonctionne à la place nécessitant un ternaire à longue haleine dans votre ffonction! Voyez également si vous pouvez supprimer l'espace qui se trouve juste après vos printdéclarations
Value Ink
Je suggérerais d'essayer un format différent pour l'explication de votre code. Ce n'est pas très lisible. Essayez de regarder comment les autres utilisateurs font les leurs. Même cela serait mieux.
mbomb007
1
re.sub("y|Y","t",chr(random.randint(33,126))+' ')[j!=i!=x-j-1]enregistre 6 octets sur la ... if ... else ...construction.
RootTwo
5

Dyalog APL , 35 octets

⎕UCS 32+(⊢+∊∘57 89)⌊?95×(⊢∨⌽)∘.=⍨⍳⎕

invite pour le numéro
1 à ce nombre
∘.=⍨table d'égalité ( à savoir la diagonale a 1s)
(⊢∨⌽)lui - même ou son image dans un miroir (donne deux diagonales)
95×multiplier par 95
?rand int entre 1 et 95 pour les diagonales, rand flotteur entre 0 et 1 pour le reste
étage à supprime les flottants,
(⊢+∊∘57 89)ajoute un aux éléments membres de {57,89} (Yy - 32),
32+ajoute 32 pour que les 0 soient des espaces, et les autres nombres, dans la plage appropriée,
⎕UCSconvertis en texte

TryAPL !

Adam
la source
J'aime la façon dont celui-ci réagit également avec des nombres pairs, même si cela ne faisait pas partie du problème (et pouvait même être involontaire). Bon travail! Cependant, curieusement, il traite parfois une entrée de 4 différemment de toute autre entrée.
Kirkpatt
@kirkpatt Ouais, je n'ai même pas remarqué "l'
intrus
3

Python 2.7, 205 octets:

from random import*;C=input()/2;S=' ';R=range;Z=lambda:chr(choice(R(33,89)+R(90,121)+R(122,128)));T=lambda*G:''.join([S*i+Z()+S*(2*(~-C-i)+1)+Z()+S*i+'\n'for i in R(*G)]);print T(C)+S*C+Z()+'\n'+T(~-C,-1,-1)

Essayez-le en ligne! (Idéone)

R. Kap
la source
3

MATL , 28 octets

6Y2'Yy 'X-iZr1MZrXdwXdP2$X>c

Essayez-le en ligne!

Tous les personnages autorisés ont la même probabilité d'apparaître. Fonctionne même pour l'entrée.

6Y2     % Predefined literal of ASCII chars from 32 to 126
'Yy '   % Not allowed chars
X-      % Set difference. Produces the set of allowed chars
i       % Input number, n
Zr      % Random sample without replacement. Gives a string with n chars taken from 
        % the allowed set
1MZr    % Do the same
Xd      % Diagonal matrix. Zeros will be displayed as spaces
wXd     % Diagonal matrix with the other string
P       % Flip vertically
2$X>    % Maximum of the two matrices
c       % Convert to char. Implicitly display
Luis Mendo
la source
3

C, 154 octets (ou 119 sans la plaque de la chaudière)

o(w,c){c=rand()%94+33;printf("%*c",w,w?c+!(c&95^89):10);}main(h){scanf("%d",&h);srand(time(0));for(int n=h,p;n--;)p=abs(h/2-n),o(h/2-p+1),p&&o(p*2),o(0);}

Ou 119 octets en fonction X(h)de srand(time(0))pris en charge ailleurs:

o(w,c){c=rand()%94+33;printf("%*c",w,w?c+!(c&95^89):10);}X(h,n,p){for(n=h;n--;)p=abs(h/2-n),o(h/2-p+1),p&&o(p*2),o(0);}

Panne:

o(w,c){                         // "Output" function, for all printing
    c=rand()%94+33;             // Generate random char, whether we need it or not
    printf("%*c",               // Print a char with some number of leading spaces
           w,                   // Use "w" (width) - 1 leading spaces
           w?                   // Either print the random char...
             c+!(c&95^89)       // (exclude "y" and "Y" by incrementing to "z"/"Z")
                         :10    // ...or print a newline if called with w = 0
    );
}
main(h){                        // Main function; repurpose argc to store grid size
    scanf("%d",&h);             // Get grid size from stdin
    srand(time(0));             // Boiler-plate for random number seeding
    for(int n=h,p;n--;)         // Loop over all lines (count down to save chars)
        p=abs(h/2-n),           // Calculate half-distance between "X" bars
        o(h/2-p+1),             // Output the first half of the "X" (">")
        p&&                     // If we are not in the centre:
           o(p*2),              //   output the second half of the "X" ("<")
        o(0);                   // Output a newline
}
Dave
la source
3

code machine x86, 70 octets

60 89 d7 31 db 43 88 ce b2 fe 49 d1 e1 87 da 0f
c7 f0 24 7f 3c 22 72 f7 48 3c 79 74 f2 3c 59 74
ee aa 49 7c 1c 00 df 79 06 86 f7 42 43 eb f6 f6
c3 01 74 03 b0 0a aa 51 88 f9 b0 20 f3 aa 59 eb
cc c6 07 00 61 c3

Mon code exécutable, désassemblé:

0000003d <myheh>:                                       
  3d:   60                      pusha                   
  3e:   89 d7                   mov    %edx,%edi        
  40:   31 db                   xor    %ebx,%ebx        
  42:   43                      inc    %ebx             
  43:   88 ce                   mov    %cl,%dh          
  45:   b2 fe                   mov    $0xfe,%dl        
  47:   49                      dec    %ecx             
  48:   d1 e1                   shl    %ecx             

0000004a <myloop>:                                      
  4a:   87 da                   xchg   %ebx,%edx        

0000004c <myrand>:                                      
  4c:   0f c7 f0                rdrand %eax             
  4f:   24 7f                   and    $0x7f,%al        
  51:   3c 22                   cmp    $0x22,%al        
  53:   72 f7                   jb     4c <myrand>      
  55:   48                      dec    %eax             
  56:   3c 79                   cmp    $0x79,%al        
  58:   74 f2                   je     4c <myrand>      
  5a:   3c 59                   cmp    $0x59,%al        
  5c:   74 ee                   je     4c <myrand>      
  5e:   aa                      stos   %al,%es:(%edi)   
  5f:   49                      dec    %ecx             
  60:   7c 1c                   jl     7e <mydone>      

00000062 <mylab>:                                       
  62:   00 df                   add    %bl,%bh          
  64:   79 06                   jns    6c <myprint>     
  66:   86 f7                   xchg   %dh,%bh          
  68:   42                      inc    %edx             
  69:   43                      inc    %ebx             
  6a:   eb f6                   jmp    62 <mylab>       

0000006c <myprint>:                                     
  6c:   f6 c3 01                test   $0x1,%bl         
  6f:   74 03                   je     74 <myprint1>    
  71:   b0 0a                   mov    $0xa,%al         
  73:   aa                      stos   %al,%es:(%edi)   

00000074 <myprint1>:                                    
  74:   51                      push   %ecx             
  75:   88 f9                   mov    %bh,%cl          
  77:   b0 20                   mov    $0x20,%al        
  79:   f3 aa                   rep stos %al,%es:(%edi) 
  7b:   59                      pop    %ecx             
  7c:   eb cc                   jmp    4a <myloop>      

0000007e <mydone>:                                      
  7e:   c6 07 00                movb   $0x0,(%edi)      
  81:   61                      popa                    
  82:   c3                      ret                     

C'est une fonction qui reçoit la taille du X dans ecx et un pointeur sur le tampon de sortie dans edx.

Il remplit la mémoire tampon de sortie séquentiellement d'octets. Il y a des 2 * n - 1itérations (égales au nombre de caractères sans espace à afficher). À chaque itération, il effectue les opérations suivantes:

  • Générer un nombre aléatoire
  • Violon avec le numéro pour l'adapter à la gamme; si c'est mauvais, retourne et génère de nouveau
  • Imprimer le caractère aléatoire
  • Imprimer une nouvelle ligne (chaque itération)
  • Imprimer le nombre approprié d'espaces

La conversion d'un nombre aléatoire en un caractère aléatoire n'est pas remarquable:

myrand:
    rdrand eax;
    and al, 7fh;
    cmp al, 22h;
    jb myrand;
    dec eax;
    cmp al, 'y';
    je myrand;
    cmp al, 'Y';
    je myrand;

La partie intéressante est le calcul du nombre d'espaces. Il doit générer les nombres suivants (exemple pour N = 9):

7    1
5    2
3    3
1    4

     3
1    2
3    1
5    0
7

Les nombres sont pris alternativement de deux progressions arithmétiques. Le premier descend à l’étape -2 et le second à l’étape 1. Lorsque la première progression arrive à -1 (au milieu du X), il y a un problème (-1 est supprimé), puis les progressions changent de direction.

Les progressions sont stockées dans des registres ebxet edx- les parties hautes bhet dhstockent le numéro actuel, et les parties basses blet dlstockent le pas. Pour alterner les progressions, le code échange les registres avec xchg.

Lorsque la progression arrive à -1 (autour de l' mylabétiquette), les deux registres sont augmentés, les étapes passant de -2, 1à -1, 2. Cela modifie également les rôles des registres, de sorte qu'il permute les parties hautes des registres.

À la fin de la fonction, il stocke un octet nul pour indiquer une fin de chaîne.

anatolyg
la source
2

Lua, 277 octets

Eh bien ... Lua est tellement bon à manipuler des chaînes: D. La première fois que je devais utiliser localdans une déclaration! Je pourrais économiser des octets en utilisant Lua 5.1 au lieu de 5.3 car ils ont déplacé la fonction globale unpackdans l’objet tablede Lua 5.2. Mais je préfère rester avec la dernière version que j'ai :).

Définit une fonction qui doit être appelée avec un seul paramètre (le second est utilisé à des fins de récurrence) et renvoie une chaîne.

function f(n,N)N=N or n e=" "p="\n"r=math.random C=e.char
R={}for i=1,4 do x=r(33,126)R[i]=x~=89 and x~=121 and x or r(33,88)end
local s,S,a,b,c,d=e:rep((N-n)/2),e:rep(n-2),table.unpack(R)return
n<2 and s..C(a)..p or s..C(a)..S..C(b)..s..p..f(n-2,N)..s..C(c)..S..C(d)..s..p
end

Ungolfed

function f(n,N)                       
  N=N or n                          -- N is equal to the n we had on the first call
  e=" "                             -- shorthand for the space
  p="\n"                            -- shorthand for the newline
  r=math.random                     -- shorthand for math.random
  C=e.char                          -- uses the string e to obtain the function string.char
  R={}                              -- define an array for our random values
  for i=1,4                         -- iterate 4 times (for the random characters)
  do
    x=r(33,126)                     -- random between ASCII "!" and "~"
    R[i]=x~=89 and x~=121           -- if we didn't pick y or Y
           and x                    -- keep this number
         or r(33,88)                -- or roll for a character between "!" and "X"
  end
  local s,S                         -- these variables have to be local
          ,a,b,c,d                  -- or the recursion would change them
         =e:rep((N-n)/2),e:rep(n-2) -- s and S are the number of spaces for the X
           ,table.unpack(R)         -- a,b,c and d are the 4 random characters
  return n<2                        -- if n==1 
           and s..C(a)..p           -- we're at the center of the X, time to end recursion
         or                         -- else
           s..C(a)..S..C(b)..s..p   -- concatenate the topmost line for n
           ..f(n-2,N)               -- with the inner X
           ..s..C(c)..S..C(d)..s..p -- and the bottom line
end
Katenkyo
la source
2

JavaScript (ES6), 137 131 125 octets

n=>[...Array(n)].map((_,i,a)=>String.fromCharCode(...a.map((r=Math.random()*94,j)=>i-j&&i+j+1-n?32:(r+72&95&&r)+33))).join`\n`

\nreprésente le caractère de nouvelle ligne littéral. Édition: 1 octet enregistré en déplaçant ' 'l’ String.fromCharCodeexpression. J'ai sauvegardé 5 octets en rendant ma génération de caractères aléatoires non uniforme; l'expression r+72&95est égale à zéro pour les valeurs mappées sur Yet yet un !est généré à leur place. Sauvegardé 4 octets quand j'ai réalisé que la propagation String.fromCharCodeévite d'avoir à le faire join. Sauvegardé 2 octets en volant un tour de @ edc65.

Neil
la source
2

PowerShell v2 +, 112 octets

Param($i)function f{Random(33..126-ne121-ne89|%{[char]$_})};1..$i|%{$a=,' '*$i;$a[$_-1]=f;$a[$i-$_]=f;$a-join''}

Lit les entrées sur la ligne de commande.

Pour chaque ligne, un tableau d'espaces est créé, les index corrects étant remplis de caractères extraits de la fonction f, puis le tableau de caractères est joint à la sortie en tant que ligne.

Ben Owen
la source
Vous pouvez économiser 6 octets en déplaçant le [char]casting en dehors de Random, et en retournant le -joinpour devenir un opérateur unaire ---Param($i)function f{[char](Random(33..126-ne121-ne89))};1..$i|%{$a=,' '*$i;$a[$_-1]=f;$a[$i-$_]=f;-join$a}
AdmBorkBork
En fait, vous pouvez enregistrer deux autres octets en remplaçant le functionpar l'équivalent PowerShell d'un lambda et en appelant l'opérateur &d'appel. Ce qui suit est 103 octets -Param($i)$z={[char](Random(33..126-ne121-ne89))};1..$i|%{$a=,' '*$i;$a[$_-1]=&$z;$a[$i-$_]=&$z;-join$a}
AdmBorkBork
En fait, en fait ;-), vous pouvez économiser davantage en réduisant votre image -ne, en transformant le [char]casting en [char[]]acteur $a(en échangeant ' 'pour 32le processus) et en déplaçant $zla définition dans un parens lors de son premier appel. Moins de 99 (woo! Sous-100!) -Param($i)1..$i|%{$a=,32*$i;$a[$_-1]=&($z={Random(33..126-ne121,89)});$a[$i-$_]=&$z;-join[char[]]$a}
AdmBorkBork
Hah, sauvegardez un autre octet en déplaçant $ala définition dans un parent après sa première utilisation. Jusqu'à 98 maintenant - Param($i)1..$i|%{($a=,32*$i)[$_-1]=&($z={Random(33..126-ne121,89)});$a[$i-$_]=&$z;-join[char[]]$a}je pense que je vais m'arrêter ici ;-) hehe
AdmBorkBork
2

MATLAB, 86 octets

a=@(n)(char(changem(randi(92,n),33+[0:55 57:87 89:93],1:92).*(eye(n)|fliplr(eye(n)))))

Quelques exemples:

>> a(1)

ans =

i


>> a(3)

ans =

~ {
 Z 
* ^


>>a(5)

ans =

k   E
 | M 
  }  
 ] s 
b   t


>> a(10)

ans =

Q        k
 +      a 
  j    w  
   X  [   
    rO    
    %3    
   P  d   
  K    q  
 r      & 
?        v
PieCot
la source
Donc, une fonction qui change les valeurs dans une matrice en fonction de certaines règles s'appelle changem! Grand nom!
Anatolyg
2

Pip , 33 octets

32 octets de code, +1 pour le -ldrapeau. Curieusement, le code commence par Yet finit par y...

Ya{$=a|$+a=y-1?RCPARM-`y`s}MMCGy

Prend l'entrée en tant qu'argument de ligne de commande. Essayez-le en ligne!

Explication

Construit une grille de la taille appropriée; remplace les éléments sur les diagonales par un caractère non-y aléatoire et tous les autres éléments par un espace.

                                  a is 1st cmdline arg; PA is printable ASCII characters;
                                  s is space (implicit)
Ya                                Yank a into y (global var, accessible within functions)
                             CGy  y by y coordinate grid
  {                       }MM     To each coordinate pair, map this function:
   $=a                             Fold on equality (true if both elements are equal)
      |                            Logical OR
       $+a                         Fold on +
          =y-1                     and test if equal to size - 1
              ?                    If the preceding expression is true, then:
                 PARM               From printable ASCII chars, remove         
                     -`y`           regex matching y, case-insensitive
               RC                   Take a random choice from the resulting string
                         s         Else, space
                                  The whole expression returns a nested list, which is
                                  autoprinted as lines of concatenated items (-l flag)
DLosc
la source
1

php, 135 octets

<?php for(;$i<$n=$argv[1];){$s=str_pad('',$n);$s[$i?:0]=chr(rand(33,126));$s[$n-++$i]=chr(rand(33,126));echo str_ireplace(Y,X,"$s
");}

Une approche assez simple utilise str_pad pour créer une chaîne d'espaces de la longueur requise, remplace les caractères nécessaires par des caractères aléatoires, puis remplace tout Ys (insensible à la casse) par X et echos la ligne.
Génère 2n + 3 avis mais, comme d'habitude, c'est bien.

utilisateur55641
la source
1

Emacs Lisp, 269 octets

(defalias'n'number-sequence)(set'c(mapcar'string(delq 89(delq 121(n 33 126)))))(defun c()(nth(random(length c))c))(defun s(x)" ")(defun x(l)(let((s(mapcar's(n 1 l))))(dotimes(i l)(set'x(copy-seq s))(setf(nth i x)(c)(nth(-(length x)i 1)x)(c))(message(apply'concat x)))))

Ungolfed et légèrement modifié:

(defvar c (mapcar 'string (delq 89 (delq 121 (number-sequence 33 126)))))
(defun c() (nth (random (length c)) c))
(defun s(x)" ")
(defun x(l)
  (let ((s(mapcar's(n 1 l)))
        x)
    (dotimes (i l)
      (set 'x (copy-seq s))
      (setf (nth i x) (c)
            (nth (- (length x) i 1) x) (c))
      (message (apply 'concat x)))))
Lord Yuuma
la source
1

JavaScript (ES6), 128 131

Éditez 3 octets enregistrés thx @Neil

Si volumineux, probablement pas la meilleure approche. Bonus - cela fonctionne avec des entrées impaires ou paires.

n=>[...Array(n)].map((_,i,z)=>String.fromCharCode(...z.map((r=1+Math.random()*94,j)=>32+(j==i|j==n+~i&&(r+7&31?r:25))))).join`
`

F=n=>[...Array(n)].map((_,i,z)=>String.fromCharCode(...z.map((r=1+Math.random()*94,j)=>32+(j==i|j==n+~i&&(r+7&31?r:25))))).join`\n`

Z=_=>{
    o=F(+S.value),O.textContent=o,/y/i.test(o)||setTimeout(Z,100)
}
setTimeout(Z,100)
<input id=S value=15 type=number>
<pre id=O></pre>

edc65
la source
Je pense r+7&31donne le même résultat que (r&31)-25.
Neil
@Neil sonne bien, merci
edc65
J'aime la façon dont cela illustre le fait que c'est aléatoire! +1
Conor O'Brien
1

C, 268 octets

V(c){for(c=89;c==89||c==121;c=rand()%95+33);return c;}p(n,s){n^1?s-n?printf("%*.c",s-n,32):0,printf("%c%*.c%c\n",V(),n*2-3,32,V()),p(n-1,s),s-n?printf("%*.c",s-n,32):0,printf("%c%*.c%c\n",V(),2*n-3,32,V()):printf("%*.c%c\n",s-n,32,V());}f(n){srand(time(NULL));p(n,n);}

Appelez f()avec la taille de xdessiner.

owacoder
la source
Vous devez appeler à l' srandintérieur de vos fonctions, elles ne peuvent pas compter sur un état global. Cependant, vous pouvez réaliser un programme beaucoup plus court avec deux boucles imbriquées et utilisant le caractère de retour arrière. Une solution générale pourrait ressembler à ceci , mais je pense qu’une variante spécifique à Windows clockserait valide.
FryAmTheEggman
Pouvez-vous louer la version de votre compilateur? sur gcc version 4.8.1Windows et gcc version 5.3.0pour Cygwin ne fonctionne pas ... (sur IdeOne Works)
Giacomo Garabello
Je sais que cela fonctionne avec GCC 6.1.0, mais cela devrait au moins fonctionner avec> 4.9. Cela fonctionne aussi avec Clang 3.8.1. Quelles erreurs voyez-vous?
owacoder
1

Matricks , 79 octets (non concurrents)

Matricks excelle comme le début de la fabrication du x et de toutes les valeurs aléatoires, mais il échoue en ce qui concerne les conditionnelles ...

J'ai marqué ceci comme non compétitif parce que je devais corriger quelques bugs et faire fonctionner toutes les nouvelles fonctionnalités après la publication de ce défi.

m:n;:1;mr=c:L:L;k({}|{X;})*{m_?33:126;;:L:l;miC<121,89>:gr:c;;:49:gr:c;;:L:l;};

Courir avec python matricks.py x.txt [[]] <input> --asciiprint

Explication:

m:n;:1;mr=c:L:L;                   #Initialize matrix to be a square with
                                   #a diagonal of 1s
k...;                              #Set the output to...
({}|{X;})*                         #The boolean x matrix multiplied by...
{m_?33:126;;:L:l;                  #A bunch of random characters
miC<121,89>:gr:c;;:49:gr:c;;:L:l;} #But make sure they are not y or Y

Cela prend également en charge les nombres pairs.

Bleu
la source
1

Python 2, 204 191 183 octets

D'accord, la concurrence de Python devient féroce ici. Voici ma tentative de supprimer autant d'octets que possible. A présent, je suis coincé (ok, encore coincé).

Crédits à @NonlinearFruit pour la façon dont les caractères aléatoires sont sélectionnés.

Version de 183 octets:

import re,random
s=i=input();t=lambda:re.sub("y|Y","t",chr(random.randint(33,126)))
while i>-s:i-=2;u=abs(i);z=(s-u)/2-1;print('',' '*-~z+t()+'\n')[-1==i]+(' '*z+t()+' '*u+t())*(i>-s)

Essayez-le en ligne! (Idéone)

Le principal changement consiste à réécrire le conditionnel

(" "*(z+1)+t()+"\n"if -1==i else"") 

comme

(""," "*-~z+t()+'\n')[-1==i]

ce qui sauve 7 octets.

Version de 191 octets:

import re,random
s=i=input();t=lambda:re.sub("y|Y","t",chr(random.randint(33,126)))
while i>-s:
 i-=2;u=abs(i);z=(s-u)/2-1;print(' '*(z+1)+t()+'\n'if -1==i else'')+(' '*z+t()+' '*u+t())*(i>-s)

Essayez-le en ligne! (Idéone)

Les principales modifications concernent la manière dont les caractères aléatoires sont sélectionnés et certaines modifications de code, telles que le s=input();i=s;devenir s=i=input();, la suppression de l' r=rangeattribution, qui n'est plus nécessaire, et l'appel absdirect, car il en résulte moins d'octets de code.

Battre la réponse la plus courte précédente en Python de 1 octet! @R. L'approche de Kap est utilisée pour générer les caractères aléatoires. A chaque itération de la boucle while, une ligne de l'ex est imprimée.

Version de 204 octets :

from random import*
s=input();i=s;a=abs;r=range;t=lambda:chr(choice(r(33,89)+r(90,121)+r(122,128)))
while i>-s:
 i-=2;z=(s-a(i))/2-1;print(' '*(z+1)+t()+'\n'if -1==i else'')+(' '*z+t()+' '*a(i)+t())*(i>-s)

Essayez-le en ligne! (Idéone)

Version non-golfée pour avoir une idée de son fonctionnement:

from random import *
random_character = lambda : chr(choice(range(33,89)+range(90,121)+range(122,128)))

size = input()
current_row = size

while current_row > -size:
    current_row-=2
    n_leading_spaces = (size-abs(current_row)/2)-1 
    row_to_print = ''
    if current_row == -1:
        row_to_print = ' ' * (n_leading_spaces+1) + random_chr() + '\n'
    if current_row > -size:
        row_to_print += ' ' * n_leading_spaces + random_chr()+' '*abs(current_row)+random_chr()
    print row_to_print

Il était difficile de gérer le cas d'un caractère!

Ioannes
la source
1

SmileBASIC, 97 octets

INPUT S
FOR X=1TO S
FOR Y=1TO S
Q=RND(93)+33?CHR$((Q+!(Q-121&&Q-89))*(X==Y||X+Y==S+1));
NEXT?NEXT

Au lieu d'avoir à calculer le nombre d'espaces entre chaque caractère ou quelque chose, j'ai décidé d'imprimer seulement dans tous les lieux où X==You X+Y==Size+1.
Le générateur de caractères aléatoires ajoute simplement 1 s'il génère you Y, ainsi zet Zsont légèrement plus communs que d'habitude.

12Me21
la source
1

PHP, 100 octets

for(;($x%=$n=$argv[1])?:$y++<$n&print"\n";)echo strtr(chr($y+$x++-$n&&$x-$y?32:rand(33,126)),yY,zZ);

prend en charge l'argument de la ligne de commande; courir avec -nr.

la boucle combinée imprime les caractères en fonction de la position

panne

for(;
    ($x%=$n=$argv[1])       // inner loop
        ?
        :$y++<$n&print"\n"  // outer loop; print newline
;)
    echo strtr(chr(             // 2. replace Y with Z; print
        $y+$x++-$n&&$x-$y       // 1: if position is not on diagonals
            ?32                 // then space
            :rand(33,126)       // else random printable
    ),yY,zZ);
Titus
la source