Remplissez ma feuille à bulles

18

Aujourd'hui était la journée d'inscription à l' examen AP dans mon école, et alors que je bouillonnais méticuleusement dans les pages et les pages d'informations requises, l'idée de ce défi m'a frappé. Donc, étant donné une chaîne de lettres et de chiffres, sortez un graphique à bulles correctement rempli.

Règles:

  • Pour chaque caractère de la chaîne d'entrée, remplacez ce caractère dans la colonne correspondante par un #ou @ou tout autre symbole raisonnable (si votre langue le gère, le caractère Unicode 'full_block': █ semble vraiment bien)
  • Un espace est représenté par une colonne vide (voir exemples)
  • Une entrée valide sera une chaîne composée uniquement de lettres majuscules, de chiffres numériques et d'espaces.
  • L'entrée sera d'une longueur avec un minimum de 1 et un maximum de 32 caractères.
  • La sortie doit être MAJUSCULE
  • Si la longueur d'entrée est inférieure à la longueur maximale de 32, votre programme doit toujours sortir les colonnes vides restantes
  • Votre programme n'a pas à gérer les entrées en minuscules de la même manière que si elles étaient en majuscules, mais des points bonus si c'est possible.

Format du conseil:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

Exemples:

CODE GOLF ->

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
█CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DD█DDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEE█EEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFF█FFFFFFFFFFFFFFFFFFFFFFF
GGGGG█GGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLL█LLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
O█OOOO█OOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999


ABCDEFGHIJKLMNOPQRSTUVWXYZ012345 ->

@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
B@BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CC@CCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDD@DDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEE@EEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFF@FFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGG@GGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHH@HHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIII@IIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJ@JJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKK@KKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLL@LLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMM@MMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNN@NNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOO@OOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPP@PPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQ@QQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRR@RRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSS@SSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTT@TTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUU@UUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVV@VVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWW@WWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXX@XXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYY@YYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZ@ZZZZZZ
00000000000000000000000000@00000
111111111111111111111111111@1111
2222222222222222222222222222@222
33333333333333333333333333333@33
444444444444444444444444444444@4
5555555555555555555555555555555@
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ->^^^

Et bien sûr, c'est du golf de code , donc la réponse la plus courte l'emporte

code-golf  ascii-art 
— X1M4L
source
7
La validation des entrées est généralement déconseillée, vous pouvez donc simplement avoir la correspondance d'entrée [A-Z0-9]{1,32}et autoriser tout comportement pour les entrées ne correspondant pas à cela.
— Giuseppe
1
Combien ridiculement ennuyeux est le fait que «0» précède «A» en code ASCII> :( lol
— NL628
"Une entrée valide sera une chaîne composée des caractères qui apparaissent sur la feuille à bulles ainsi que des espaces" mais vous indiquez également "Tout caractère autre que les lettres majuscules, les espaces et les chiffres, ou dépassant la limite de 32 caractères. devrait être ignoré " , alors lequel est-ce?
— Kritixi Lithos
1
Mais selon la première déclaration, vous dites que $cela n'apparaîtra pas dans les entrées
— Kritixi Lithos
1
Maintenant que vous avez supprimé les chiffres et les caractères innalid des spécifications, vous pouvez également les supprimer des exemples.
— Titus

Réponses:

4

Husk , 23 octets

mż§?'#|=⁰mR32¤+…"AZ""09

Essayez-le en ligne ou essayez-le avec le caractère fantaisie █ (mais un nombre d'octets invalide)!

Malheureusement, je n'ai pas pu fusionner les deux maps en un (sauf en utilisant des parenthèses, ce qui coûte 24 octets).

Explication

mż§?'#|=⁰mR32¤+…"AZ""09"  -- expects string as argument, eg. "FOO"
             ¤            -- with the two strings "AZ" "09" ..
               …          -- | fill ranges: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          -- |              "0123456789"
              +           -- .. and concatenate: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
          m               -- map the following (eg. with 'X')
                          -- | replicate 32 times: "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                          -- : ["A…A","B…B",…,"Z…Z","0…0",…"9…9"]
m                         -- map the following (eg. with "F…")
 ż      ⁰                 -- | zipWith (keeping elements of longer list) argument ("FOO")
  §?   =                  -- | | if elements are equal
    '#                    -- | | | then use '#'
      |                   -- | | | else use the first character
                          -- | : ["#FF…F"]
                          -- : ["A…A",…,"#FF…F",…,"O##O…O",…,"9…9"]
— ბიმო
source
4

Rubis , 62 octets

->s{[*?A..?Z,*?0..?9].map{|c|(0..31).map{|i|c==s[i]??@:c}*''}}

Essayez-le en ligne!

Renvoie un tableau de chaînes. Pourrait être joué plus loin en rejetant les jointures de chaînes et en renvoyant un tableau 2D de caractères comme c'est généralement la norme, mais je ne suis pas sûr si cela est autorisé ici.

— Kirill L.
source
3

C (gcc) , 132 126 octets

char*s="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",*_,*a;f(char*x){for(_=s;*_;++_,puts(""))for(a=s;*a;)putchar(x[a++-s]-*_?*_:64);}

Essayez-le en ligne!

Merci à Jonathan Frech d'avoir économisé 6 octets.

— LambdaBeta
source
puts("")est équivalent à putchar(10).
— Jonathan Frech
++a)putchar((x[a-s]-*_)?*_:64);-> )putchar(x[a++-s]-*_?*_:64);.
— Jonathan Frech
Si vous êtes prêt à contourner un peu les règles, vous pouvez également jouer 64au golf 1.
— Jonathan Frech
Si vous le faites, l' putcharappel pourrait être joué au golf putchar(*_*(*_!=a[x-s]));.
— Jonathan Frech
Normalement, je serais d'accord pour plier les règles pour cela ... mais 1 est une bête très différente d'un rectangle rempli ou d'un signe @. Les autres changements sont cependant utiles - seront mis à jour.
— LambdaBeta
3

Rouge , 177 octets

func[s][m: copy[]foreach c a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[insert/dup r: copy"^/"c 32 append m r]j: 0
foreach c s[j: j + 1 if c <>#" "[m/(index? find a c)/(j): #"@"]]m]

Essayez-le en ligne!

Plus lisible:

f: func[s][
    m: copy[]
    a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    foreach c a[
        insert/dup r: copy "^/" c 32
        append m r
    ]
    j: 0
    foreach c s[
        j: j + 1
        if c <>#" "[m/(index? find a c)/(j): #"@"]
    ]
    m
]
— Galen Ivanov
source
3

Fusain , 21 octets

Ｅ⁺α⭆…αχκ⭆…◨θφ³²⎇⁼ιλ#ι

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

  α  α                  Uppercase alphabet predefined variable
      χ                 Predefined variable 10
    …                   Chop to length
   ⭆                    Map over characters and join
       κ                Current index
 ⁺                      Concatenate
Ｅ                       Map over characters into array
           θ            Input string
            φ           Predefined variable 1000
          ◨             Right pad to length
             ³²         Literal 32
         …              Chop to length
        ⭆               Map over characters and join
                 ι  ι   Current outer character
                  λ     Current inner character
                ⁼       Equals
                   #    Literal `#`
               ⎇        Ternary
                        Implicitly print each result on its own line

Version précédente avec validation d'entrée, 34 32 octets. Edit: enregistré 2 octets grâce à @ ASCII uniquement.

≔⁺α⭆…αχκαＥα⭆…◨Φθ∨⁼ι №αιφ³²⎇⁼ιλ#ι

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

— Neil
source
: / vous semblez manquer une parenthèse étroite à la fin
— ASCII uniquement
On dirait que ça marche. (Wolfram StringReplace) Sur une note latérale, un remplacement intégré serait très pratique à droite
— ASCII uniquement
Tant pis, je ne sais pas ce que je faisais. 27 octets - vous n'avez pas besoin duCast
— uniquement ASCII
Aussi, re: le pad avec un caractère arbitraire que vous demandiez avant: pensez-vous que ce serait assez utile pour l'ajouter comme intégré? ou peut-être comme une fonction intégrée à deux caractères?
— ASCII uniquement
23
— ASCII uniquement
3

Gelée ,  18  17 octets

ØA;ØDWẋ32ɓ,€⁶y"ZY

Utilise un caractère espace. Pour utiliser un #remplacer ⁶par ”#pour un coût d'un octet.

Essayez-le en ligne!

Comment?

ØA;ØDWẋ32ɓ,€⁶y"ZY - Main Link: list of characters, S   e.g.  ['S','P','A','M']
ØA                - upper-case alphabet characters           ['A','B',...,'Z']
   ØD             - digit characters                         ['0','1',...,'9']
  ;               - concatenate                              ['A','B',...,'Z','0','1',...,'9']
     W            - wrap in a list                           [['A','B',...,'Z','0','1',...,'9']]
      ẋ32         - repeat 32 times                          [['A','B',...,'Z','0','1',...,'9'],...,['A','B',...,'Z','0','1',...,'9']]
         ɓ        - start a new dyadic chain with that on the right
            ⁶     - space character                          ' '
          ,€      - pair €ach of S with a space              [['S',' '],['P',' '],['A',' '],['M',' ']]
              "   - zip with:
             y    -   translate (replace 'S' with ' ' in 1st, 'P' with ' ' in 2nd, ...) -- Note: zip is a zip-longest, so trailing lists remain
                Z  - transpose
                 Y - join with line-feeds
                   - implicit print
— Jonathan Allan
source
Je peux enregistrer un octet.
— Erik the Outgolfer le
Welp, je suis aussi arrivé ³Ḣ,⁶yØA;ØD¤µ32СZYà 18 ans, ce qui, je pense, peut aussi être amélioré! Sortir si ...
— Jonathan Allan
Donc, évidemment, ce n'est pas l'octet dont je parle. :) Essayez plus fort ...
— Erik the Outgolfer
Incroyable j'ai réussi à jouer au golf sur mobile 17 octets
— Jonathan Allan
Le mien était en fait ça , mais bravo!
— Erik the Outgolfer
2

C ++ 14, 319 octets 237

C'est la première fois que je fais cela, dans le pire langage CodeGolf possible: P

char c;string k="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",s;int main(){map<char,vc>g;g[' ']=vc(32,' ');for(char c:k)g[c]=vc(32,c);getline(cin,s);for(int i=0;i<s.length();i++)g[s[i]][i]='@';for(char d:k){for(char x:g[d])cout<<x;cout<<'\n';}}

Essayez-le en ligne!

— NL628
source
Question: Dois-je inclure l'en-tête?
— NL628
S'il est nécessaire d'exécuter le code, il doit figurer dans votre réponse. Cela dit, vous pouvez supprimer à peu près tous les espaces et que cette réponse fonctionne toujours.
Puis-je réécrire ceci en tant que fonction avec des paramètres, au lieu d'un main ()?
— NL628
@ NL628 oui vous le pouvez. Voir les conseils pour jouer au golf en C ++ pour plus d'aide. EDIT: lien commuté vers C ++
— Giuseppe
1
COBOL quelqu'un? Je n'y ai jamais écrit de ligne de code, mais l'utilisation de COBOL pour le golf de code peut être un défi intéressant.
— Hans-Martin Mosner
2

Node.js, 85 octets

Port vers Node.js suggéré par @DanielIndie

f=(s,x=544,c=Buffer([48+x/32%43]))=>x<1696?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

Essayez-le en ligne!

JavaScript (ES6), 103 98 octets

f=(s,x=544,n=x>>5,c=String.fromCharCode(48+n%43))=>n<53?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

Essayez-le en ligne!

— Arnauld
source
90 octets que diriez-vous de cela?
— DanielIndie
@DanielIndie Merci! Ajoutée. (Nous n'en avons pas vraiment besoin +"", n'est-ce pas?)
— Arnauld
Je ne sais jamais si nous devons convertir ou non, donc je n'y pense pas: P mais oui, vous n'en avez pas vraiment besoin :)
— DanielIndie
@DanielIndie Ah, maintenant, nous pouvons simplement utiliser x/32pour enregistrer 2 octets de plus, car il Bufferest contraint aux entiers.
— Arnauld
f=(s,x=561,c=Buffer([48+x/33%43]))=>x<1749?(s[x++%33]==c?'@':x%33?c:`\n`)+f(s,x):''
— l4m2
2

Haskell , 86 octets

Pour une approche beaucoup plus agréable (et moins d'octets), voir la solution de Laikoni !

f x=(x#).(<$[1..32])<$>['A'..'Z']++['0'..'9']
(a:b)#(u:v)=last(u:['#'|a==u]):b#v
_#w=w

Essayez-le en ligne!

Alternativement, pour le même nombre d'octets, nous pourrions utiliser:

(a:b)#(u:v)|a==u='#':b#v|0<3=u:b#v

Essayez-le en ligne!

Explication / Non golfé

L'opérateur (#)est très similaire zipWithmais la fonction est codée en dur, st. il utilise# si deux caractères sont égaux et sinon il garde le deuxième, non golfé:

(a:b) # (u:v)
   | a == u    = '#' : b # v
   | otherwise =  u  : b # v

Si la première liste est épuisée, elle ajoute simplement les éléments restants de la seconde:

_ # w = w

Avec cet assistant, nous devons seulement générer la chaîne "A..Z0..9", répliquer chaque élément 32 fois et compresser l'entrée avec chaque chaîne, sans golf:

f x = map ((x#) . replicate 32) (['A'..'Z'] ++ ['0'..'9'])
— ბიმო
source
1
— Laikoni
@Laikoni: Dommage que ce soit juste 1 octet de moins, c'est une utilisation vraiment intelligente de max. Je pense que vous devriez publier cela comme votre propre solution car elle est très différente de ma solution.
— 2018
J'ai posté une version 74 octets .
— Laikoni
2

Haskell , 74 octets

f x=[do a<-take 32$x++cycle" ";max[c]['~'|a==c]|c<-['A'..'Z']++['0'..'9']]

Essayez-le en ligne! Une chaîne d'entrée xest remplie d'espaces jusqu'à une longueur de 32 avectake 32$x++cycle" " . Pour chaque caractère cde Aà Zet 0à 9, nous regardons les caractères ade la chaîne d'entrée rembourrée et les remplaçons par ~quand aet csont égaux et cautrement. Ceci est réalisé par max[c]['~'|a==c], qui est par exemple max "A" "~" = "~"quand a = c = 'A', etmax "A" "" = "A" quand c = 'A'et a = 'B'. Parce que cela produit une chaîne singleton au lieu d'un caractère, la do-notation est utilisée qui concatène les chaînes singleton en une seule chaîne.

Basé sur la solution Haskell de BMO .

— Laikoni
source
2

Python 2, 138 octets

Prend en charge les caractères majuscules et minuscules et laisse une colonne vide pour les espaces.

def f(s):
 s=s.upper()
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))

Si le bonus n'en vaut pas la peine, je choisirai 125 octets et ne prendrai en charge que les entrées majuscules:

def f(s):
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))
— sonrad10
source
2

Stax , 15 octets

╛dδÑ-═E↑\≈Fà±AG

Exécuter et déboguer

Il utilise '#' pour indiquer une bulle remplie.

Déballé, non golfé et commenté, il ressemble à ceci.

32(     right-pad or truncate to 32
{       begin block for mapping
  VAVd+ "A..Z0..9"
  s'#+  move input character to top of stack and append "#". e.g. "C#"
  |t    translate; replace the first character with the second in string
m       perform map using block
Mm      transpose array of arrays and output each line

Exécutez celui-ci

— récursif
source
1

Pyth, 23 20 octets

j.Tm:s+r1GUTdN.[Qd32

Essayez-le ici

Explication

j.Tm:s+r1GUTdN.[Qd32
              .[Qd32      Pad the input to 32 characters.
   m                      For each character...
     s+r1GUT              ... get the string "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"...
    :       dN            ... with the character replaced by a '"'.
j.T                       Transpose the lines and print them all.
1

APL + WIN, 56 octets

Demande la chaîne d'entrée et utilise le caractère # comme identifiant:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10]⋄((,m[;1]∘.=32↑⎕)/,m)←'#'⋄m

Explication:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10] create the table

32↑⎕ pad the input string to 32 characters with spaces

(,m[;1]∘.=32↑⎕) use outer product with = to identify characters in table

((,m[;1]∘.=32↑⎕)/,m)←'#' replace characters with #

m display table

⋄ statement separator
— Graham
source
1

C (gcc) , 124 octets

f(s,b,x,y)char*s,b[33];{sprintf(b,"%-32.32s",s);for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),s=b;*s;putchar(*s++==y?35:y));}

Essayez-le en ligne!

Au lieu d'un tableau codé en dur, je l'ai remplacé par une fonction de recherche à la place. Heureusement, le jeu de caractères ASCII a des plages alphabétiques et numériques contiguës (je vous regarde, EBCDIC!) De plus, je me suis assuré de garder la sortie à exactement 32 caractères en utilisant sprintf(): si ce n'était pas une exigence de la tâche, le la fonction serait de 97 octets:

f(s,i,x,y)char*s,*i;{for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),i=s;*i;putchar(*i++==y?35:y));}

Essayez-le en ligne!

— ErikF
source
— plafondcat
1

CJam , 31 octets

q32Se]{'[,65>A,s+S+_@#St);}%zN*

Essayez-le en ligne! Utilise les espaces comme caractère "trou".

Si un espace de fin est autorisé, cela fonctionne pour 29 octets :

q32Se]{'[,65>A,s+S+_@#St}%zN*

Essayez-le en ligne!

Voici une variation de 34 octets qui utilise à la place le bloc complet Unicode ( █):

q32Se]{'[,65>A,s+S+_@#'█t);}%zN*

Essayez-le en ligne!

Explication

q                                Input.
    e]                           Pad to a length of
 32                                32
                                 with
   S                               spaces.
      {                   }%     For each character:
                                   Get the uppercase alphabet by
            >                        dropping the first
          65                           65
                                     elements of
         ,                             the range of characters below
       '[                                '['.
                +                  Append
               s                     the string version
              ,                        of the range of numbers below
             A                           10.
                  +                Append
                 S                   a space.
                     #             Find the index of
                    @                the character.
                       t           Set this index to
                      S              a space
                   _               in the original array.
                        );         Drop the space at the end.
                                   Yield this modified array.
                                 End for. The result is an array of arrays of characters.
                            z    Transpose this array, turning rows into columns.
                             N*  Join the result on newlines.
— Esolanging Fruit
source
1

05AB1E , 19 octets

RтúR32£vžKuÙyð:})ø»

Essayez-le en ligne!

Explication

R                     # reverse
 тú                   # prepend 100 zeroes
   R                  # reverse
    32£        }      # take the first 32 characters
       v              # for each character
        žK            # push a string of [a-zA-Z0-9]
          uÙ          # upper case and remove duplicates
            yð:       # replace current character with space
                )ø    # transpose
                  »   # join by newline
— Emigna
source
a[b]ne fonctionne pas comme vous le voulez ici, est-ce: P?
— Urne de poulpe magique du
@MagicOctopusUrn: Malheureusement non. C'était aussi ma première pensée, mais l'indexation modulaire n'est pas notre amie dans ce cas: P
— Emigna
1

MATL , 21 octets

1Y24Y2vjO33(32:)y=~*c

Utilise un espace comme caractère marqueur.

Essayez-le en ligne!

Explication

1Y2     % Push 'AB...YZ'
4Y2     % Push '01...89'
v       % Concatenate into a 36×1 column vector of chars
j       % Push unevaluated input: string of length n, or equivalently 1×n
        % row vector of chars
O33(    % Write 0 at position 33. This automatically writes a 0 at postions
        % n+1, n+2, ..., 32 too
32:)    % Keep only the first 32 entries: gives a 1×32 row vector
y       % Duplicate from below: pushes a copy of the 36 ×1 column vector
=~      % Test for non-equal entries, with broadcast. Gives a 33×32 matrix
        % containing 0 for matching entries, and 1 otherwise
*       % Multiply this matrix by the 1×32 row vector, with broadcast. This
        % changes each 1 into the corresponding character in the input
c       % Convert to char. Implicitly display. Char 0 is displayed as space
— Luis Mendo
source
1

Lisp commun , 150 octets

(setq s(format nil"~32a"(read-line)))(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

Essayez-le en ligne!

Explication

;; pad input to 32 spaces on the right
(setq s(format nil"~32a"(read-line)))
;; for each character in bubble sheet, for each character in input:
;; if characters are equal print "#"
;; else print bubble sheet character
(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
— ASCII uniquement
source
1

Java 10, 120 118 117 117 octets

s->{var r="";for(char c=65,i;c<91&c!=58;r+="\n",c+=c<90?1:-42)for(i=0;i<32;i++)r+=i<s.length&&s[i]==c?35:c;return r;}

Essayez-le en ligne (pour TIO, j'ai utilisé '█' ( 9608au lieu de35 ) pour une meilleure visibilité).

Explication:

s->{                   // Method with character-array parameter and String return-type
  var r="";            //  Result-String, starting empty
  for(char c=65,i;     //  Start character `c` at 'A'
      c<91&c!=58       //  Loop as long as `c` is 'Z' or smaller, and is not '9'
      ;                //    After every iteration:
       r+="\n",        //     Append a new-line to the result-String
       c+=c<90?        //     If `c` is not 'Z' yet
           1           //      Go to the next character ASCII-value-wise
          :            //     Else:
           -42)        //      Change the 'Z' to '0'
    for(i=0;i<32;i++)  //    Inner loop `i` in the range [0,32)
      r+=i<s.length    //     If we're not at the end of the input array yet,
         &&s[i]==c?    //     and the characters in the column and array are the same
          35           //      Append the filler-character '#'
         :             //     Else:
          c;           //      Append the current character instead
  return r;}           //  Return the result-String
— Kevin Cruijssen
source
1

Rétine , 64 octets

$
36* 
L`.{36}
.
36*@$&¶
Y`@`Ld
(.)(.*)\1
@$2
N$`\S
$.%`
L`.{32}

Essayez-le en ligne!

$
36* 
L`.{36}

Remplit la chaîne d'entrées à droite avec des espaces à 36 caractères

.
36*@$&¶
Y`@`Ld

Ensuite, mettez chaque personnage sur sa propre ligne et ajoutez ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 avant.

(.)(.*)\1
@$2

Faites correspondre une paire du même caractère sur la même ligne, qui existe si et seulement si le caractère de cette ligne correspond à l'un des ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 . Remplacez le premier par @et retirez le second.

N$`\S
$.%`

Les seules lignes sans correspondance sont celles avec des espaces, donc les caractères non-espace sont un bloc carré 36 × 36. Transpose-le.

L`.{32}

Conserver uniquement les 32 premiers caractères de chaque ligne

— TwiNight
source
1

Tcl , 153 145 octets

Merci @sergiol pour -8 octets

lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {puts [join [lmap j [split [format %-32s [join $argv ""]] ""] {expr {$i==$j?"#":$i}}] ""]}

Essayez-le en ligne!

Explication

# for i in list of choices
lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {
    # print string of
    puts [join
        # list of
        [lmap j
             # for each character in first argument padded to 32 characters
             [split [format %-32s [join $argv ""]] ""]
             # return "#" if current choice and current character are equal, else current choice
             {expr {$i==$j?"#":$i}}
        ]
        ""
    ]
}
— ASCII uniquement
source
152
— sergiol
@sergiol: | Oui, ça l'est. 146 ?
— ASCII uniquement
1
145
— ASCII uniquement
1

SNOBOL4 (CSNOBOL4) , 155 150 bytes

	I =INPUT
	U =&UCASE '0123456789'
N	U LEN(1) . K REM . U	:F(END)
	O =DUPL(K,32)
	X =
S	I LEN(X) @X K	:F(O)
	O POS(X) K =' '	:S(S)
O	OUTPUT =O	:(N)
END

Essayez-le en ligne!

Explication:

	I =INPUT			;* read input
	U =&UCASE '0123456789'		;* U = uppercase concat digits
N	U LEN(1) . K REM . U	:F(END)	;* while U not empty, pop first letter as K
	O =DUPL(K,32)			;* dup K 32 times
	X =				;* set position to 0
S	I LEN(X) @X K	:F(O)		;* find the next occurrence of K and save (index - 1) as X
	O POS(X) K =' '	:S(S)		;* replace the X'th occurrence of K with space. If that's before character 32, goto S, else proceed to next line
O	OUTPUT =O	:(N)		;* output the string and goto N
END
— Giuseppe
source
1

Prolog (SWI) , 235 229 228 222 214 214 198 173 167 165 octets

-6 octets grâce à @Cows quack , -6 octets grâce à @ 0 ' 

X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
_+[].
X+[H|T]:-H*X,X+T.
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.

Essayez-le en ligne!

Explication

% if head = bubble char, write "#", else write bubble char, then while tail is non-empty, recurse.
% if tail is empty then print newline
X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
% if list is empty, then do nothing. this prevents t from being called with invalid X
_+[].
% call t, then recurse for each char in list
X+[H|T]:-H*X,X+T.
% read, pad input to 32 chars, and convert input to list
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.
— ASCII uniquement
source
0

Octave , 61 octets

@(s)[((a=[30:55 13:22]'*~~(o=1:32)).*(a+35~=[s o](o)))+35 '']

Essayez-le en ligne!

La fonction fonctionne comme suit:

@(s)[                                                     ''] %Anonymous function, taking string, outputting character array   
         [30:55 13:22]'                                       %Creates the board alphabet ('A':'Z' '0':'9']) but minus 35 (value of '#')
                       *~~(o=1:32)                            %Matrix multiplication by an array of 32 1's to form the 2D board. Saves 1:32 for later.
      (a=                         )                           %Saves the board mimus 32 to a for use later.
                                            [s o](o)          %Ensures the input is 32 characters long. Missing chars replaced by 1:32 (not in board)
                                     (a+35~=        )         %Compares against board (a+35 as a=board-35). Makes 2D array where matches = 0, others = 1. 
     (                             .*                )+35     %Element=wise multiplication, forcing matches to 0. Then add 35 resulting in board with #'s
— Tom Carpenter
source
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.