Faire un bol de soupe à l'alphabet


55

Voici ce que nous appellerons un bol de soupe à l'alphabet - une forme approximativement circulaire d'ascii-art avec les 26 lettres majuscules anglaises (AZ) disposées dans le sens des aiguilles d'une montre pour former le périmètre:

   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK

Ecrivez un programme qui prend une lettre, un AZ, et sort ce même bol de soupe à l'alphabet "pivoté", pour ainsi dire, de sorte que la lettre d'entrée apparaisse là où le Afait dans l'exemple ci-dessus et le reste de l'alphabet tourne complètement autour dans le sens des aiguilles d'une montre.

La sortie pour l'entrée Aserait donc ce même bol original de soupe à l'alphabet.

Et la sortie pour l'entrée Bserait celle-ci:

   YZABCD
 WX      EF
V          G
U          H
T          I
 SR      KJ
   QPONML

De même, le résultat pour Hserait:

   EFGHIJ
 CD      KL
B          M
A          N
Z          O
 YX      QP
   WVUTSR

Ou pour Z:

   WXYZAB
 UV      CD
T          E
S          F
R          G
 QP      IH
   ONMLKJ

Cela doit fonctionner pour les 26 lettres, de A à Z.

Détails:

  • Vous pouvez supposer que la seule entrée sera une seule lettre, de A à Z.
  • Si cela vous convient, vous pouvez utiliser une lettre minuscule az pour entrée et / ou sortie, vous pouvez même mélanger des combinaisons de lettres minuscules et majuscules.
  • L'ordre alphabet doit tourner dans le sens des aiguilles d'une montre et non dans le sens contraire.
  • Vous devez utiliser des espaces, pas autre chose, pour mettre en retrait et remplir le bol à soupe.
  • Il peut y avoir des nouvelles lignes ou des espaces dans la sortie tant que le bol de soupe est bien disposé.
  • Notez que la forme du bol est large de 12 caractères sur 7 pour le rendre approximativement circulaire en tant que texte. Vos bols doivent avoir la même forme.

C'est du code golf donc le code le plus court gagne!


12
Grand défi! Au début, cela semble facile, mais ce n’est pas le cas
Luis Mendo

Réponses:


22

05AB1E , 21 octets

Définit un programmef:AlphabeticCharString

Code:

2AA¹k._•1못*Ć,ãiDΣ•Λ

Essayez-le en ligne!


Panne:

2AA¹k._•1못*Ć,ãiDΣ•Λ

2                       # <length>
 AA¹k._                 # <filler>
       •1못*Ć,ãiDΣ•    # <pattern>
                    Λ   # Invoke the canvas function.


Explication:

La toile ( Λ) dans ce contexte particulier fonctionne comme une fonction avec la signature suivante:

Λ:(length:Nat, filler:String, pattern:Nat)String

Le est dans cette situation un nombre définissant les directions. Dans le code, ce nombre est représenté sous la forme d' une version compressée du grand nombre . Les directions sont notées de la manière suivante:pattern 2232344565666667670012122•1못*Ć,ãiDΣ•2232344565666667670012122


70162543


Cela signifie que le grand nombre représente le modèle de directions suivant:

[,,,,,,,,,,,,,,,,,,,,,,,,]

Avec ce contexte de signature, le canevas parcourt la liste et écrit les caractères de dans la direction actuelle.patternlengthfiller

Le est spécifié dans le code par (au début du code). Pour le , nous avons besoin d’une version pivotée de l’alphabet telle qu’elle commence par l’entrée donnée. Cela se fait avec le code suivant ( essayez-le ici ):length2filler

AA¹k._

 A¹k # Trouver le <index> du caractère saisi dans l'alphabet
A ._ # Faites pivoter l’alphabet vers la gauche <index> fois.

En pseudocode, cela serait exécuté par la fonction canvas:

1.Write ab in the direction2.Write bc in the direction3.Write cd in the direction4.Write de in the direction5.Write ef in the direction6.Write fg in the direction

Enfin, vous pouvez voir que l'argument de remplissage est 'tourné' fois à droite, ce qui signifie que le canevas va parcourir la liste suivante (cyclée et donc infinie):length1

[ab,bc,cd,de,ef,fg,gh,hi,ij,jk,...

Ce qui donne la forme désirée de l'alphabet soupe ascii-art.


Ok, j'abandonne. Essayé de trouver des alternatives plus courtes, mais je ne le vois pas. AA¹k._peut être alternativement A¹¡RJ«, mais c'est le même nombre d'octets. •1못*Ć,ãiDΣ•peut être alternativement •õÕ₆qηµñ–†f•·, mais c'est le même nombre d'octets. Et bien. Bonne réponse!
Kevin Cruijssen

11

Perl 6 , 100 octets

{"2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK".trans(/\S/=>{(try ' 'x$/+1)||chr ($/.ord+.ord)%26+65})}

Essayez-le en ligne!

Remplace toutes les lettres de la chaîne par leurs équivalents décalés, tout en remplaçant les chiffres par le nombre d'espaces qu'ils représentent plus un.

Explication

{                                                            }# Anonymous code block
 "...".trans(/\S/=>{                                       }) # Translate non-whitespace
                    (try ' 'x$/+1)      # If digits, the amount of spaces plus one
                                  ||chr ($/.ord+.ord)%26+64  # Else the shifted letter


9

Ruby , 107 octets

->n{a=(0..6).map{' '*11}
(?A..?Z).map{|i|j,k=(1i**((i.ord-n.ord-6)/6.5)).rect;a[3.5*k+=1][5.2*j+6]=i}
a*$/}

Essayez-le en ligne!

Amélioration de la syntaxe "i".to_c-> 1i(suggéré par la Jordanie)

Système de coordonnées modifié pour que 0 degrés soit à droite au lieu de haut. Cela permet 0.5->6

Multiplicateurs ajustés de jet kpour la brièveté

Plutôt que d’imprimer la sortie puts a, concaténez des éléments de tableau et renvoyez une chaînea*$/

Ruby , 119 octets

->n{a=(0..6).map{' '*11}
(?A..?Z).map{|i|j,k=("i".to_c**((i.ord-n.ord+0.5)/6.5)).rect;a[3.5-j*3.3][6+k*5.17]=i}
puts a}

Utilise un nombre complexe élevé au pouvoir de mapper sur une ellipse. Un tour complet est 26, donc chaque quadrant est 6,5.

Cette approche repose sur le résultat requis, qui ressemble à une ellipse, suffisamment pour qu’un mappage valide puisse être réalisé.

Essayez-le en ligne!


@ Jordan, je n'ai jamais vu cette syntaxe auparavant!
Level River St

8

Charbon de bois , 33 octets

GH→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→²✂⁺αα⌕αS

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

GH

Trace un chemin.

→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→

Décrivez le bol. Chacun se 7développe à ↙←.

²

Déplacer un caractère à la fois (cette API chevauche la fin de chaque ligne avec la suivante).

✂⁺αα⌕αS

Dessinez en utilisant l'alphabet doublé, mais en partant de la position du caractère saisi.


8

MATL , 49 octets

7I8*32tvB[1b]&Zvc2Y2j7+_YSy&f7-w4-_Z;YPE\,&S])yg(

Quel bordel. Mais c'était amusant d'écrire. Il y a même un arctangent impliqué.

Essayez-le en ligne!

Explication

Le code

7I8*32tvB

crée un tableau de nombres et les convertit en binaire. Cela donne la matrice zéro-un

0 0 0 1 1 1
0 1 1 0 0 0
1 0 0 0 0 0
1 0 0 0 0 0

qui est le quadrant supérieur gauche d'une matrice spécifiant les positions des lettres.

[1b]&Zv

reflète ce quadrant verticalement sans répéter la dernière ligne, et horizontalement la dernière colonne pour produire la matrice complète:

0 0 0 1 1 1 1 1 1 0 0 0
0 1 1 0 0 0 0 0 0 1 1 0
1 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 0 1
0 1 1 0 0 0 0 0 0 1 1 0
0 0 0 1 1 1 1 1 1 0 0 0

Nous avons maintenant un masque avec les positions. Le code

c

convertit ceci en char, car le résultat final sera une matrice de caractères. Le caractère 0 est affiché sous forme d'espace et les entrées non nulles seront écrites avec les lettres appropriées.

2Y2

pousse la chaîne 'abc···xyz'qui contient les 26 lettres. Cette chaîne doit être déplacée de manière circulaire conformément à l'entrée. Pour faire ça,

j7+_YS

lit la lettre d'entrée, ajoute 7 à son code ASCII et annule le résultat. Pour l'entrée, 'a'cela donne −104, ce qui est un multiple de 26, donc un déplacement circulaire de ce montant ne fera rien. Si l'entrée est, bcela donne -105, ce qui décale la chaîne d'un pas vers la gauche pour produire 'bcd···yza'; etc.

L'étape suivante consiste à définir l'ordre dans lequel la chaîne décalée sera écrite dans les entrées non nulles de la matrice. À cette fin,

y&f

crée une copie de la matrice et pousse deux vecteurs contenant les positions de ligne et de colonne basées sur 1 du nonzer. ensuite

7-w4-_

soustrait 7 de ce dernier, amène le premier au sommet, en soustrait 4 et le nie. Les 7 et 4 spécifient une origine de coordonnées, de sorte que les angles des vecteurs de position des entrées non nulles par rapport à cette origine définissent l'ordre souhaité.

Z;YPE\

calcule l'arctangent modulo 2 * pi à deux arguments pour produire ces angles. Maintenant, le plus petit angle, qui est 0, correspond à l'entrée où la première lettre doit être insérée, et le reste avance dans le sens anti-horaire.

,&S])

réorganise les lettres dans la chaîne en fonction de ces angles, afin que le résultat soit correct lorsque les lettres sont écrites dans les entrées non nulles de la matrice dans l’ordre ordre principal des colonnes (bas, puis en regard). Ceci est fait par

yg(

Par exemple, si l'entrée est 'a'la chaîne n'a pas été déplacée de manière circulaire:

abcdefghijklmnopqrstuvwxyz

Le réarrangement selon les angles transforme cela en

utsvrwqxpyoznamblckdjeifgh

donc cela 'u'ira correctement à la première entrée non nulle (en ordre de colonne, ordre majeur), qui est (3,1) en notation matricielle; 't'ira à (4,1), 's'à (5,1); 'v'à (2,2) etc:

   ······   
 v·      ·· 
u          ·
t          ·
s          ·
 ··      ·· 
   ······   

@EriktheOutgolfer J'ai enfin trouvé le temps d'ajouter une explication
Luis Mendo

1
Woah ... Je pensais en fait que vous aviez abandonné cela parce que vous aviez supprimé ce commentaire. : P
Erik the Outgolfer


7

R , 139 122 octets

-17 octets grâce à Giuseppe

u=utf8ToInt;`*`=rep;o=c(' '*12,'
')*7;o[u("  &3@LKWVUTSRDC5(")]=LETTERS[(13:38+u(scan(,'')))%%26+1];cat(o,sep='')

Explication:

o=rep(c(rep(' ',12),'
'),7) 

Construit une boîte vide d'espaces

u(" &3@LKWVUTSRDC5(")

est un ensemble d'indices pour les positions de lettres correspondant à:

c(7:9,23,24,38,51,64,76,75,87:82,68,67,53,40,27,15,16,4:6)

TIO


1
vous n'utilisez jamais, intToUtf8donc ce sont des octets superflus, mais si vous utilisez *à la place de rep, vous pouvez obtenir une sauvegarde de 2 octets et atteindre 125 octets
Giuseppe

1
Oh, et en utilisant les caractères avec un petit octet au lieu d’ascii imprimable, vous pouvez vous débarrasser de la -32, pour 122 octets . Vous pouvez les générer vous-même en utilisant cat(intToUtf8(bytes)).
Giuseppe

@ Giuseppe J'étais à peu près sûr d'avoir déjà supprimé le intToUtf8, trop de versions de la fonction ouvertes en même temps, je suppose. Belle enregistre tous roundthough, merci
Aaron Hayman

6

JavaScript (Node.js) ,  121  119 octets

2 octets sauvés grâce à @tsh

c=>`2XYZABC
0VW5DE
U9F
T9G
S9H
0RQ5JI
2PONMLK`.replace(/./g,x=>''.padEnd(+x+1)||(B=Buffer)([65+([a,b]=B(c+x),a+b)%26]))

Essayez-le en ligne!

Comment?

Ce code permet Bufferd’extraire les codes ASCII de la lettre type et de la lettre et de les reconvertir en lettre cible.xc

Exemple avec etc=x ="H"x="B"

// extracting the ASCII codes
Buffer(c + x)  Buffer("HB")  <Buffer 48 42>

// assigning them to variables
[a, b] = Buffer(c + x)  a = 0x48 (72) and b = 0x42 (66)

// computing the ASCII code of the target letter
65 + ((a + b) % 26)  65 + (138 % 26)  65 + 8  73

// turning it back into a character
Buffer([73])  <Buffer 49>  implicitly coerced to "I" by replace()



4

R , 218 197 octets

-21 octets grâce à Giuseppe

function(t,l=letters,`*`=rep,s=" ",n="
",`~`=`[`,r=c(l~l>=t,l))cat(s*3,r~24:26,r~1:3,n,s,r~22:23,q<-s*6,r~4:5,n,r~21,u<-s*10,r~6,n,r~20,u,r~7,n,r~19,u,r~8,n,s,r~17:18,q,r~10:9,n,s*3,r~16:11,sep='')

Essayez-le en ligne!

Ungolfed:

alphasoup <- function(startlet){
  startnum <- which(l == startlet)
  rotatedletters <- c(letters[startnum:26], letters[1:(startnum -1)])[1:26]
  cat('   ',rotatedletters[24:26],rotatedletters[1:3], '\n ', 
      rotatedletters[22:23], s6 <- '      ', rotatedletters[4:5], '\n',
      rotatedletters[21], s10 <- rep(' ', 10), rotatedletters[6], '\n',
      rotatedletters[20], s10, rotatedletters[7], '\n',
      rotatedletters[19], s10, rotatedletters[8], '\n ',
      rotatedletters[17:18], s6, rotatedletters[10:9], '\n   ',
      rotatedletters[16:11],
      sep = '')
}

Crée un vecteur de lettre pivoté et utilise catpour remplir le bord du bol avec ce vecteur.


203 octets si vous ne vous souciez pas des monstruosités sur une ligne; La plus grande amélioration a probablement été de supprimer whichet d'utiliser l>=tdirectement l'index, qui valait 12 octets.
Giuseppe

2
198 octets par aliasing [avec ~. C'est une excellente réponse; Je passais environ 250 octets lors de mes premières tentatives avec une approche beaucoup plus complexe.
Giuseppe

Ah, c'est intelligent, j'oublie les comparaisons de chaînes.
CT Hall

3

Java 11, 134 octets

c->"2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK".chars().forEach(i->System.out.print(i<59?" ".repeat(i-47):(char)(i>90?10:(c+i)%26+65)))

Essayez-le en ligne.

Version de 136 octets avec le potentiel d'être joué au golf?

c->"2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK".chars().forEach(i->System.out.printf("%"+(i<59?i-47:"")+"c",i>90?10:i<59?32:(c+i)%26+65))

Essayez-le en ligne.

Explication (de la première réponse)

c->                          // Method with character parameter and no return-type
  "2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK"
                             //  Template-String
    .chars().forEach(i->     //  Loop over the unicode values of its characters:
    System.out.print(        //   Print:
     i<59?                   //    If the value is below 59 (so a digit character):
      " ".repeat(i-47)       //     Repeat a space that digit + 1 amount of times
     :(char)(i>90?           //    Else-if the value is above 90 (an underscore character):
              10             //     Print a newline
             :               //    Else:
              (c+i)          //     Add the current value and the input together
                   %26       //     Take modulo-26 of it to get the index in the alphabet
                      +65))) //     And add 65 to make it an uppercase letter

Pourquoi ne pas remplacer les chiffres par des non imprimables? De cette façon, vous pourriez simplement omettre lei-47
Incarnation de l'Ignorance

@EmbodimentofIgnorance Je crains que cela ne sauve aucun octet. Les nombres d'espaces sont 3, 1, 6 et 10. Le nombre 10 est utilisé trois fois et représente 2 octets chacun en tant que caractère ( \n). Donc, que j'utilise non imprimables et 3x \navec iou chiffres-1 avec i-47, les deux sont identiques 134. Et malheureusement, je ne peux pas avoir d’imprimable 0, sinon j’aurais pu utiliser 2,0,5,9 à la place et i+1économiser 1 octet au total.
Kevin Cruijssen

2

Wolfram Language (Mathematica) , 258 octets

(t[x_]:=Table[" ",x];w=RotateRight[Alphabet[],4-LetterNumber@#];j=Join;a[x_,y_]:=j[{w[[x]]},t@10,{w[[y]]}];b[m_,n_]:=j[t@1,w[[m;;m+1]],t@6,w[[n;;n+1]],t@1];""<>#&/@{j[t@3,w[[1;;6]]],b[25,7],a[24,9],a[23,10],a[22,11],Reverse@b[12,20],j[t@3,w[[19;;14;;-1]]]})&

Essayez-le en ligne!


2

Haskell, 127 octets

("cXYZABC aVWfDE UjF TjG SjH aRQfJI cPONMLK">>=).(?)
t?c|c>'Z'=' '<$['a'..c]|c<'!'="\n"|t<'B'=[c]|c>'Y'=t?'@'|1<2=pred t?succ c

Essayez-le en ligne!

Chaque caractère de la chaîne codée est décodé par fonction ?dans une chaîne:

t?c                             -- 't' is the starting char,
                                -- 'c' the char from the encoded string
   |c>'Z'=' '<$['a'..c]         -- if 'c' is a lowercase letter, return some spaces
                                -- 'a': one, 'b': two, etc
   |c<'!'="\n"                  -- if 'c' is a space, return a newline
   |t<'B'=[c]                   -- if 't' is the letter A, return 'c'
   |c>'Y'=t?'@'                 -- wrap around Z
   |1<2=pred t?succ c           -- else the result is the same as starting one letter
                                -- earlier (pred t) but looking at the successor of 'c'

2

Kotlin , 148 146 145 octets

Suppression des parenthèses supplémentaires pour -2
Chaîne brute remplacée pour -1

{l:Char->"2XYZABC 0VW5DE U9F T9G S9H 0RQ5JI 2PONMLK".map{c->if(c>'@')((c-'A'+(l-'A'))%26+65).toChar()
else if(c>' ')" ".repeat(c-'/')
else '\n'}}

Essayez-le en ligne!


2

C # (compilateur interactif Visual C #) , 126 118 octets

n=>$@"   XYZABC
 VW{"",6}DE
U {"",9}F
T {"",9}G
S {"",9}H
 RQ{"",6}JI
   PONMLK".Select(b=>b<65?b:(char)((b+n)%26+65))

Sauvegardé 8 octets grâce à @quelqu'un. Oui, c'est en fait son nom d'utilisateur.

Essayez-le en ligne!


Interpolation de chaîne pour 118 octets . Il est probablement acceptable de renvoyer un tableau de codes (économisant environ 8 octets), mais je ne suis pas sûr.
quelqu'un

@quelqu’un de Nice a oublié l’interpolation des cordes
Incarnation de Ignorance

2

Requête TSQL, 238 octets

DECLARE @y char='G'

,@ char(91)=3;WITH C as(SELECT'5585877636333330301125255'z,8a,ascii(@y)x
UNION ALL
SELECT stuff(z,1,1,''),a+left(z,1)/3*13+left(z,1)%3-14,(x+14)%26+65FROM
C WHERE''<z)SELECT
@=stuff(stuff(@,a,1,char(x)),1+a/13*13,1,char(13))FROM
C PRINT @

Le lien de test pour cette réponse a cassé les sauts de ligne et exclu les espaces. J'ai remplacé les espaces par des points et remplacé car (13) par car (13) + car (10) afin d'afficher un résultat lisible.

Essayez-le en ligne

Ungolfed:

DECLARE @y char='G'

-- @ is the string being printed last. 
-- @ is populated with 3 to save a byte
-- the number 3 gets replaced later
-- (this could have been any 1 digit value), 
-- @ is automatically filled with spaces, because
-- it is declared as a char(x) and assigned a value
,@ char(91)=3;
-- recursive query
WITH C as
(
-- z string containing digits for the direction of next letter
-- z should not contain 4 because it will point to same position.
-- values in z 0,1,2,3,4,5,6,7,8 can logally convert to 
-- (-1,-1),(-1,0),(-1,1),(0,-1),(0,0),(0,1),(1,-1),(1,0),(1,1)
-- a is the starting position
  SELECT'5585877636333330301125255'z,8a,ascii(@y)x
  UNION ALL
-- stuff remove first character from the z string
-- a calculate next position of the next letter
-- x cycle the input letter
  SELECT stuff(z,1,1,''),a+left(z,1)/3*13+left(z,1)%3-14,(x+14)%26+65
-- repeat recursive until long string is empty
  FROM C
  WHERE''<z
)
SELECT
-- 1st stuff replace the character to created the start of a 
--   logical line in the string @ this is where 3 gets overwritten
-- 2nd stuff replaces a character(space if coded correct) 
--  with the letter at the calculated position.
  @=stuff(stuff(@,a,1,char(x)),1+a/13*13,1,char(13))
FROM C

PRINT @

@ MickyT ok, merci pour vos commentaires, je réglerai ça plus tard aujourd'hui si je peux avoir accès à une base de données
t-clausen.dk

@MickyT il devrait être corrigé maintenant
t-clausen.dk

1
semble bon maintenant.
MickyT

1

PHP , 236 229 226 octets

<?=($a=ord(file_get_contents('php://stdin'))-65)?preg_replace_callback('~\w~',function($m)use($a){return chr((ord($m[0])-65+$a)%26+65);},'   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK'):'';

Essayez-le en ligne!

Pré-golf:

<?php
$adjust = ord(file_get_contents('php://stdin')) - 65;
echo preg_replace_callback('~\w~', function($match) use ($adjust) {
    $new = ord($match[0]) - 65;
    $new = ($new + $adjust) % 26;
    $new += 65;
    return chr($new);
}, '   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK');

Explication:

En utilisant, ordnous convertissons en un entier compris entre 0 et 255. A est égal à 65 et Z à 90.
En utilisant cette connaissance, nous prenons l'entrée et la réduisons de 65 pour obtenir une valeur d'ajustement.
Nous parcourons ensuite tous les personnages, appelons- ordles, réduisons-les de 65, augmentons-les de notre valeur d'ajustement. En utilisant modulo, nous rediffusons à 0 s'ils dépassent 26.
Nous les augmentons ensuite de 65 et les convertissons en lettres avec chr.

Malheureusement, php: // stdin ne peut être interogé qu’une fois. Nous devons donc passer l’entrée à la fonction dans notre boucle, nous empêchant de sauvegarder des octets use($a)et de devoir déclarer une variable en dehors de la fonction nous empêche d’utiliser proprement la <?=méthode echo - nous devons tout emballer dans un ternaire géant.


1

C (GCC) 286 octets

Pas exactement le golf le plus court, mais ça marche

#define r(a)(a+c)%26+65
#define R(a)for(i=10;i;a[--i]<33?:(a[i]=r(a[i])));
i;f(c){char*S="          ",T[]="   XYZABC\n",E[]="VW      DE\n",F[]="RQ      JI\n",B[]="   PONMLK";R(T)R(E)R(F)R(B)printf("%s %s%c%s%c\n%c%s%c\n%c%s%c\n %s%s",T,E,r(85),S,r(70),r(84),S,r(71),r(83),S,r(72),F,B);}

Essayez-le en ligne





0

Javascript (V8), 316 octets

function a(b){n="abcdefghijklmnopqrstuvwxyz".split(b);n=b+n[1]+n[0],console.log(`   ${n[23]+n[24]+n[25]+n[0]+n[1]+n[2]}\n ${n[21]+n[22]}      ${n[3]+n[4]}\n${n[20]}          ${n[5]}\n${n[19]}          ${n[6]}\n${n[18]}          ${n[7]}\n ${n[17]+n[16]}      ${n[9]+n[8]}\n   ${n[15]+n[14]+n[13]+n[12]+n[11]+n[10]}`)}

Essayez-le en ligne

Première fois que vous essayez le code de golf. Apprécier les conseils / commentaires.

Code original avant de minifier:

function a(b){
    var c = ("abcdefghijklmnopqrstuvwxyz").split(b);
    c = b+c[1]+c[0]
    console.log(`   ${c[23]+c[24]+c[25]+c[0]+c[1]+c[2]}\n ${c[21]+c[22]}      ${c[3]+c[4]}\n${c[20]}          ${c[5]}\n${c[19]}          ${c[6]}\n${c[18]}          ${c[7]}\n ${c[17]+c[16]}      ${c[9]+c[8]}\n   ${c[15]+c[14]+c[13]+c[12]+c[11]+c[10]}`)
}

Bonjour et bienvenue sur PPCG. Dans l'état actuel des choses, votre soumission est un extrait de code contenant une entrée / sortie non valide. S'il vous plaît, fixez votre réponse pour qu'il s'agisse d'un programme complet ou d'une fonction - comme dans votre version non détaillée.
Jonathan Frech

@ Jonathan Fresch merci! Cela suffirait-il?
Edwin Chua

1
Oui, c'est maintenant une soumission valide.
Jonathan Frech


0

C (gcc) , 200 198 197 octets

-3 octets grâce à ceilingcat.

x,z;f(c){char*y,t[27],i=0;for(c-=46;i<14;t[13+i++]=(c-i)%26+65)t[i]=(c+i)%26+65;for(i=-4;++i<4;printf("%*.*s%*.*s\n",3273>>x*3&7,x?:1,y,z,x?:1,y+2*!i+z))z="--*%"[x=abs(i)]-34,y=t+x+(x>2)+13*(i>0);}

Essayez-le en ligne!


0

PHP , 131 octets

for(;$s='2YZABCD
 WX5EF
V9G
U9H
T9I
 SR5KJ
2QPONML'[$i++];)echo$s<A?$s<'0'?$s:str_pad('',$s+1,' '):chr(65+(ord($s)+ord($argn))%26);

Essayez-le en ligne!

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.