Faire de la pluie alphabet


54

Alphabet Rain

La tâche:

Le principe de base consiste à imprimer la chaîne d'entrée, puis à répéter chaque caractère verticalement, en fonction de sa position (indexé sur 0) dans l'alphabet (insensible à la casse) A-Z. Aest à l'emplacement 0 donc n'est pas répété, eest à la position 4 donc est répété 4 fois, Pest à la position 15 donc est répété 15 fois, !n'est pas àA-Z est répété 0 fois, etc.

Pour plus de clarté, tout ce qui tombe en dehors de la plage B-Zb-z , par exemple des chiffres ou des caractères spéciaux, ne sera pas répété et n'apparaîtra donc que sur la première ligne.

C'est du , donc la solution la plus courte dans chaque langue est gagnante.

Contribution:

  • La saisie se fera dans le jeu de caractères ASCII imprimable standard, de 32 à 126.~ .
  • La chaîne en entrée aura 1 caractère ou plus.
  • Il n'y aura pas d'espaces de début ou de fin.
  • Vous pouvez prendre la saisie sous forme de chaîne ( "hello") ou une liste de caractères ( ["h", "e", "l", "l", "o"])

Exemples:

Entrée de aaaadonne:

aaaa

Entrée de abcdadonne:

abcda
 bcd
  cd
   d

L'entrée de Programming Puzzles & Code Golf!, donne:

Programming Puzzles & Code Golf!
Progr mming Puzzles   Code Golf
Progr mming Puzzles   Code Golf
Progr mming Puzzles    ode Golf
Progr mming Puzzles    o e Golf
Progr mming Puzzl s    o   Golf
Progr mming Puzzl s    o   Gol
Pro r mmin  Puzzl s    o    ol
Pro r mmin  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzz  s    o    o
Pro r    n  Puzz  s    o    o
Pro r       Puzz  s    o    o
Pr  r       Puzz  s
 r  r        uzz  s
 r  r        uzz  s
             uzz  s
             uzz
             uzz
              zz
              zz
              zz
              zz
              zz

L'entrée de ~|[abc<0>cba]|~, donne:

~|[abc<0>cba]|~
    bc   cb
     c   c

Remarques:

  • les failles standard s'appliquent
  • la sortie peut être une liste de chaînes, mais:
  • les retours à la ligne ne sont pas autorisés (un seul \nsur la ligne finale est acceptable)
  • la sortie peut être une liste de listes de caractères, à condition qu'il pleuve
  • pas de nouvelle ligne principale
  • à nos utilisateurs nordiques qui ont quelques lettres supplémentaires dans leur alphabet "AZ", n'hésitez pas à les soutenir, mais cela ne fait pas partie du défi

2
Un seul leader est-il \n acceptable?
Lynn

@ Lynn, pas de nouvelles lignes majeures, la première ligne devrait être la chaîne d'entrée / liste de caractères - je mettrai à jour le message!
streetster

18
FWIW, je pense qu'ils ressemblent plus à des glaçons qu'à la pluie
caird coinheringaahing 10/10

@cairdcoinheringaahing semble presque festif
Pureferret

:( Just Nordic?
ASCII uniquement

Réponses:


22

6502 code machine (C64), 113 octets

00 C0 20 FD AE 20 9E AD 85 FB 20 A3 B6 A0 00 84 FC B1 22 99 6F C1 C9 41 90 14 
C9 5B B0 04 E9 40 B0 0E C9 C1 90 08 C9 DB B0 04 E9 C0 B0 02 A9 00 99 6F C0 C5 
FC 30 02 85 FC C8 C4 FB D0 D3 A9 00 99 6F C1 A0 C1 A9 6F 20 1E AB A9 0D 20 D2 
FF A6 FC D0 01 60 C6 FC A0 00 B9 6F C1 F0 E6 BE 6F C0 D0 07 A9 20 99 6F C1 D0 
05 CA 8A 99 6F C0 C8 D0 E7

screenshot

Démo en ligne

Utilisation: sys49152,"[string]" , par exemple sys49152,"Programming Puzzles & Code Golf!".

Important: Si le programme a été chargé à partir du disque (comme dans la démo en ligne), lancez d'abord une newcommande! Cela est nécessaire car le chargement d'un programme machine supprime certains pointeurs C64 BASIC.

Remarque: le C64 est par défaut en mode sans lettres minuscules. Pour pouvoir entrer une chaîne de casse mixte, passez tout d'abord au mode minuscule en appuyant sur SHIFT+ CBM.


Explication

Voici une liste de désassemblage commentée:

         00 C0       .WORD $C000        ; load address
.C:c000  20 FD AE    JSR $AEFD          ; consume comma
.C:c003  20 9E AD    JSR $AD9E          ; evaluate expression
.C:c006  85 FB       STA $FB            ; store string length
.C:c008  20 A3 B6    JSR $B6A3          ; free string
.C:c00b  A0 00       LDY #$00           ; initialize counter
.C:c00d  84 FC       STY $FC            ; and number of "extra" lines
.C:c00f   .copyloop:                    
.C:c00f  B1 22       LDA ($22),Y        ; load next character
.C:c011  99 6F C1    STA .outbuf,Y      ; store to buffer
.C:c014  C9 41       CMP #$41           ; compare with 'a'
.C:c016  90 14       BCC .zerocount     ; smaller -> no repetition
.C:c018  C9 5B       CMP #$5B           ; compare with 'z'
.C:c01a  B0 04       BCS .checkupper    ; larger -> check for uppercase
.C:c01c  E9 40       SBC #$40           ; subtract 'a' ('a' - 1 and carry)
.C:c01e  B0 0E       BCS .cl_storecount ; and jump to store in repeat count
.C:c020   .checkupper:                  
.C:c020  C9 C1       CMP #$C1           ; compare with 'A'
.C:c022  90 08       BCC .zerocount     ; smaller -> no repetition
.C:c024  C9 DB       CMP #$DB           ; compare with 'Z'
.C:c026  B0 04       BCS .zerocount     ; larger -> no repetition
.C:c028  E9 C0       SBC #$C0           ; subtract 'A' ('A' - 1 and carry)
.C:c02a  B0 02       BCS .cl_storecount ; and jump to store in repeat count
.C:c02c   .zerocount:                   
.C:c02c  A9 00       LDA #$00           ; store 0 ...
.C:c02e   .cl_storecount:               
.C:c02e  99 6F C0    STA .repcount,Y    ; ... in repeat count
.C:c031  C5 FC       CMP $FC            ; compare with number of extra lines
.C:c033  30 02       BMI .cl_next       ; smaller -> go on with loop
.C:c035  85 FC       STA $FC            ; repeat count to number of extra lines
.C:c037   .cl_next:                     
.C:c037  C8          INY                ; next
.C:c038  C4 FB       CPY $FB            ; compare with string length
.C:c03a  D0 D3       BNE .copyloop      ; not yet reached? -> repeat
.C:c03c  A9 00       LDA #$00           ; terminate string in buffer
.C:c03e  99 6F C1    STA .outbuf,Y      ; with 0 byte
.C:c041   .outloop:                     
.C:c041  A0 C1       LDY #>.outbuf      ; output ...
.C:c043  A9 6F       LDA #<.outbuf      ; ...
.C:c045  20 1E AB    JSR $AB1E          ; ... string
.C:c048  A9 0D       LDA #$0D           ; and output ...
.C:c04a  20 D2 FF    JSR $FFD2          ; ... newline
.C:c04d  A6 FC       LDX $FC            ; load extra line count
.C:c04f  D0 01       BNE .ol_step       ; not zero -> go on
.C:c051  60          RTS                ; WE ARE DONE HERE ;)
.C:c052   .ol_step:                     
.C:c052  C6 FC       DEC $FC            ; decrease extra line count
.C:c054  A0 00       LDY #$00           ; initialize counter
.C:c056   .eraseloop:                   
.C:c056  B9 6F C1    LDA .outbuf,Y      ; load next character from buffer
.C:c059  F0 E6       BEQ .outloop       ; 0 byte? -> end of string, output
.C:c05b  BE 6F C0    LDX .repcount,Y    ; load repeat count for this characer
.C:c05e  D0 07       BNE .el_step       ; not 0 yet? -> jump to decrement
.C:c060  A9 20       LDA #$20           ; load code for space
.C:c062  99 6F C1    STA .outbuf,Y      ; store in current string position
.C:c065  D0 05       BNE .el_next       ; and jump to next loop iteration
.C:c067   .el_step:                     
.C:c067  CA          DEX                ; decrease repeat count ...
.C:c068  8A          TXA                ; ... and ...
.C:c069  99 6F C0    STA .repcount,Y    ; ... store back
.C:c06c   .el_next:                     
.C:c06c  C8          INY                ; increase counter ...
.C:c06d  D0 E7       BNE .eraseloop     ; and jump back to loop

.C:c06f   .repcount:
.C:c06f              .RES $100          ; 256 bytes for repeat count
.C:c16f   .outbuf:
.C:c16f              .RES $100          ; 256 bytes as buffer for output

3
code machine c64. Je suis impressionné.
Dschoni

@Dschoni merci, mais c'est toujours du code simple (et c'est amusant, pour moi!) - vous devriez jeter un coup d'œil à la scène de démonstration pour des œuvres vraiment impressionnantes en C64;)
Felix Palmen

Si nous continuons à en obtenir, nous voudrons peut-être configurer des liens vers un émulateur JavaScript C64 afin que les gens puissent les voir s'exécuter.
trlkly

1
@trlkly J'ai un tel lien dans ma soumission, cliquez sur "Démo en ligne";)
Felix Palmen

14

05AB1E , 13 12 octets

,εDlAsk×}ζ»,

Essayez-le en ligne!

Explication

,             # print input
 ε      }     # apply to each char in input
  D           # duplicate
   l          # convert to lower case
    Ask       # get index of current char in the lower case alphabet
       ×      # repeat the char that many times
         ζ    # transpose with space as filler
          »,  # join on newlines and print

32
Besoin d'obtenir un index des caractères en minuscule? rien que Askpour ça
Uriel

8

Pyth, 12 10 9 octets

.tm+*xGr0

Suite de tests.

Explication:

.tm+*xGr0dddQ   Expanded program with autofilled input variable
  m      dddQ    For each character d in the input:
       r0d     get its lowercase variant
     xG        and return its 0-based index in the alphabet 
                   (-1 if not found, for special chars)
                (empty string for A/a and special characters)
    *     d    that many of the corresponding character
   +       d   and one more for good measure (because x is 0-indexed)
.t             Transpose it and fill blanks with spaces

12 octets:

j.t*VmxGr0d

(avec une nouvelle ligne)

Suite de tests.

Explication:

j.t*VmxGr0d
QQ              Expanded program with autofilled input variable
Q               print the input verbatim
     m    dQ    For each character d in the input:
        r0      get its lowercase variant
      xG        and return its 0-based index in the alphabet 
                    (-1 if not found, for special chars)
   *V       Q   multiply the corresponding characters in (the second autofilled input)
                 by their alphabet indices we just calculated
                 (empty string for A/a and special characters)
 .t             Transpose it and fill blanks with spaces
j               Join the result on newlines

la sortie peut être une liste de listes de caractères, pourvu qu'il semble pleuvoir des caractères - Vous n'avez donc pas besoin de çaj
M. Xcoder

Ah tu as raison! Je le conservais parce que la version de 12 octets imprimait une ligne textuellement et je ne pouvais pas mélanger les formats de cette manière, et j'oubliais que je pouvais le supprimer maintenant que tout est dans la transposition. Merci!
Steven H.

8

Python 3 , 83 octets

f=lambda s,k=65:[*{*s}-{' '}]and[s]+f([[' ',c][91>ord(c.upper())>k]for c in s],k+1)

Essayez-le en ligne! Prend une liste de personnages. Retourne une liste de listes de caractères.

Python 2 , 90 octets

f=lambda s,k=65:s.strip()and s+'\n'+f(''.join([' ',c][91>ord(c.upper())>k]for c in s),k+1)

Essayez-le en ligne! Prend une ficelle. Retourne une chaîne.


7

Mathematica, 115 89 octets

Il prend comme inputune liste de caractères [{"a", "b", "c", "d", "a"}] et sort une liste de listes de caractères

Thread[PadRight[Table[#,Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]]&/@#]/. 0->" "]&

Essayez-le en ligne!

-26 octets de Misha Lavrov

-5 octets de l'utilisateur202729

mais si vous voulez voir la sortie telle qu'elle est dans le scénario de test, essayez ce code (128 octets).
Essayez-le en ligne!


Pour les futurs lecteurs: la partie "cette réponse ne fonctionne que sur Mathematica ..." est un peu trompeuse, le problème est que Mathematica ne prend en charge que les caractères Unicode en mode bloc-notes (REPL). En mode script , il ne comprend que les caractères ASCII et les caractères spéciaux convertis en ASCII (par exemple, (3 octets) -> \[Infinity](11 octets)).
user202729

@ user202729 ok, je vais éditer et contacter les gens pour lire vos commentaires
Merci

Suggestion de golf pour Mathematica (mode script): \[Infinity](11 octets) peut être remplacée par Infinity(8 octets) ou \:221e(6 octets). Le dernier est la représentation par défaut des caractères spéciaux sans nom. (bien que ce ne soit pas la partie principale)
user202729

Nous pouvons éviter Infinitycomplètement. La partie problématique est If[(d=Min@Position[Alphabet[],If[UpperCaseQ@#,ToLowerCase@#,#]])==∞,1,d]et nous pouvons changer cela en Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]. (En recherchant dans la liste {#,b,c,d,...,y,z}, nous sommes assurés de trouver #au moins une fois.)
Misha Lavrov

@MishaLavrov très gentil. résolu le!
J42161217

6

Dyalog APL , 27 22 octets

5 octets sauvegardés grâce à @ Adám

⍉∘↑⊢⍴¨⍨127|⎕A819⌶⍨∘1

Essayez-le en ligne!

Comment?

⍴¨⍨ - façonner chaque caractère à la longueur de

    1⌈ - au moins un ou

    ⎕A⍳819⌶⍨∘1 - index du caractère majuscule dans l'alphabet

        27| - modulo 27

- aplatir à une matrice

- et transposer



@ Adám merci! mise à jour
Uriel



5

Python 2 , 111 106 99 98 97 87 93 octets

s=input()
i=65
while s.strip():print s;s=''.join([' ',c][91>ord(c.upper())>i]for c in s);i+=1

Essayez-le en ligne!


whilepeut être remplacé par execpour économiser quelques octets, ipeut commencer par 65 pour en économiser plus pour atteindre 87 octets
Rod

Le PO indique que les retours à la ligne ne sont pas autorisés , mais votre code en imprime plusieurs lorsque l'entrée ne contient pas zou Z.
Lynn

@ Lynn Corrigé, j'ai oublié de vérifier le execchangement ...
TFeld

5

C # (.NET Core) , 162 octets

s=>{string A="abcdefghijklmnopqrstuvwxyz",r=s;for(int i=-1;++i<s.Max(A.IndexOf);)r+='\n'+string.Concat(s.Select(c=>A.IndexOf(char.ToLower(c))>i?c:' '));return r;}

Essayez-le en ligne!


2
Bienvenue sur PPCG et belle première réponse. Vous pouvez raccourcir votre code en utilisant quelques astuces. Voici une version plus golfée de votre code: Essayez-le en ligne! .
Ian H.

Merci pour les commentaires, j'ai supposé que mon code devait être exécutable par lui-même, donc je l'ai construit sur cette hypothèse! Merci pour le commentaire et le mentorat.
Nejosan

2
Si vous voulez trouver d'autres astuces sur la façon de jouer au golf en C #, jetez un coup d'œil à cet article ou consultez les réponses existantes en C #. Bon golf!
Ian H.

Bonne réponse. Continuez :)
aloisdg dit: Réintégrer Monica

1
Bonjour, bienvenue sur PPCG! Super première réponse, surtout maintenant que c'est golfé. +1 de moi. BTW, il est actuellement de 180 octets, et non 162. L'importation requise using System.Linq;est malheureusement obligatoire d'ajouter le nombre d'octets (ou vous devez changer Maxà System.Linq.Maxet Selectà System.Linq.Max, ce qui serait plus élevé que simplement using System.Linq;une fois.) Encore une fois la bienvenue, et profiter de votre séjour. Oh, et je vois @IanH. déjà mentionné Conseils pour le golf en C #. Des astuces pour jouer au golf dans <toutes les langues> peuvent également être intéressantes à lire.
Kevin Cruijssen

5

Bash, 78 , 76 71 octets

for c in {B..a};{ [[ -n ${1// } ]]&&echo "$1";set "${1//[!$c-Z${c,}-z]/ }";}

Selon le classement (LC_ALL par défaut), vous pouvez économiser quelques octets supplémentaires.

for c in {b..z} _;{ [[ -n ${1// } ]]&&echo "$1";set "${1//[!$c-Z]/ }";}

Essayez-le en ligne


4

Perl 5 , 43 octets

Code de 41 octets + 2 pour -nl.

$c=A;print,s/$c|[^a-z]/ /gi,$c++while/\S/

Essayez-le en ligne!


1
boucle pour [_0-9] caractères, peut s/["-$c]/ /gi- être et -lpas nécessaire
Nahuel Fouilleul

@NahuelFouilleul Ahh, oui, j'ai été un peu trop rapide sur les cas tests. Ils devraient être ajoutés au PO! :) Merci! +4 :(
Dom Hastings

ma suggestion ne fonctionne pas pour les caractères compris entre 32 et 126 (valeur non supérieure à Z)
Nahuel Fouilleul

@NahuelFouilleul Impossible de trouver un moyen plus court qui réponde à toutes les exigences ... Je continuerai à jouer ...
Dom Hastings

4

JavaScript (ES6), 87 78 76 octets

-9 octets grâce à @RickHitchcock .
-2 octets grâce à @Neil .

f=(s,i=10)=>s.trim()&&s+`
`+f(s.replace(/./g,c=>parseInt(c,36)>i?c:" "),i+1)

Prend les entrées sous forme de chaîne et retourne avec une nouvelle ligne.

Cas de test


76 octets (une nouvelle ligne): f=(s,i=10)=>s.trim()&&s+'newline'+f(s.replace(/./g,c=>parseInt(c,36)-i?c:" "),i+1)
Rick Hitchcock

@RickHitchcock Cela semble être une boucle infinie pour une chaîne d'entrée contenant des nombres: essayez-le en ligne! . L'idée de changements étape par étape sest vraiment bien, cependant.
Justin Mariner

Ahh, bon point. Cela peut être corrigé au prix de 2 octets:parseInt(c,36)-i>0
Rick Hitchcock

1
@ RickHitchcock Ne pouvez-vous pas utiliser à la parseInt(c,36)>iplace pour sauvegarder 2 octets?
Neil

@ Neil, duh. Justin: Ce que Neil a dit. :)
Rick Hitchcock

4

R, 118 114 octets

function(a)while(grepl("[^ ]",a)){F=F+1;cat(a,"\n");for(j in c("[^a-zA-Z]",letters[F],LETTERS[F]))a=gsub(j," ",a)}

Merci à @ Giuseppe pour ces 4 octets

Essayez-le en ligne!

Brève explication:

function(a)
    while(grepl("[^ ]",a)){ #As long as the string is not just spaces.
        F=F+1 #Increment letter counter (F is FALSE, hence 0 by default)
        cat(a,"\n") #Print string
        for(j in c("[^a-zA-Z]",letters[F],LETTERS[F])) #Get rid of non-letters, and the current letter in lower and upper case
             a=gsub(j," ",a)
    }

ohhh, attends, problème potentiel: si atous les espaces sont affichés, cela n’affiche rien ... mais vous pouvez changer la whilecondition pour grepl()|!Flaquelle il reste un octet plus court que votre réponse originale.
Giuseppe

4

R , 125 123 octets

Outgolfé par Plannapus

for(i in 1:max(p<-pmax(1,match(tolower(S<-el(strsplit(scan(,""),''))),letters),na.rm=T)))cat(ifelse(p<i," ",S),'\n',sep='')

Essayez-le en ligne!

Imprime sur stdout avec une nouvelle ligne de fin et lit à partir de stdin() .

Décomposons:

S <- el(strsplit(scan,""))            # split the string to characters

m <- match(tolower(S),letters)        # 1-based index in letters (lowercase a-z)
p <- pmax(1,m,na.rm=T)                # parallel max, replaces NA (non-alphabet) or 0 with 1
for(i in 1:max(p)){                   # iterate
 cat(                                 # print
  ifelse(p<1,' ',S),                  # the corresponding letter in S if p>=1, space otherwise
  '\n',sep='')                        # newline, and no spaces between chars
}

Réponse alternative, 106 octets

function(S)for(i in 1:max(p<-pmax(1,match(tolower(S),letters),na.rm=T)))cat(ifelse(p<i,' ',S),'\n',sep='')

Essayez-le en ligne!

Une fonction; imprime sur stdout mais c’est essentiellement ma réponse ci-dessus qui accepte d’accepter une liste de caractères plutôt que de scinder la chaîne, alors j’ai l’impression que c’est une «triche». De plus, l'approche de Plannapus avec regex est très soignée!



3

Japt , 15 14 11 10 octets

Première chance de jouer avec les nouvelles méthodes de rembourrage de chaînes de Japt afin qu'il y ait encore place à amélioration.

y_ùZInZu c

L'essayer


Explication

Entrée implicite de chaîne U.

y_

Passez chaque colonne de Uvia une fonction, où Zest l'élément en cours (ou une lettre, dans ce cas).

InZu c

Convertissez Zen majuscule ( u), obtenez son charcode ( c) et subtract ( u) 64 ( I).

ùZ

Tapotez le début Zavec avec lui-même jusqu'à ce qu'il atteigne cette longueur.


Alternative

y_ùZ9aZn36

L'essayer


Mais ne pourriez-vous pas changer ùZpour psauver un ... peu importe, c'est vraiment intelligent ...
ETHproductions

@ETHproductions: J'ai fait quelques tentatives avec p(il peut y en avoir 1 dans l'historique d'édition) mais j'ai ùfinalement gagné.
Shaggy

3

Haskell , 137 136 127 119 octets

import Data.Char
p c=last$0:[k|k<-[0..25],k+65==ord(toUpper c)]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$map p s]]

Essayez-le en ligne!

Assez long, mais je ne vois aucun moyen de le raccourcir davantage. Je pense qu'il doit y avoir un chemin plus court que la syntaxe if-then mais je ne le vois pas.

EDIT: Merci @streetster pour m'aider à réduire un octet! Je ne l'ai pas utilisé toUpperau début à cause du coût d'importation, Data.Charmais j'ai oublié qu'il fournit aussiord beaucoup plus court quefromEnum

EDIT 2: Merci à @Laikoni pour avoir supprimé 6 octets supplémentaires et identifié un bogue que j'ai corrigé. J'ai utilisé 26 au lieu de 25 parce que j'ai oublié que les tableaux Haskell sont inclusifs. Ensuite, j'ai remarqué que je pouvais utiliser lastau lieu de headce qui me permettrait d'utiliser0: plutôt que ++[0].

EDIT 3: Merci encore Laikoni pour ces 8 octets. J'avais en fait oublié cet espace. Pour une raison quelconque, Sublime Text disparaît sans lui et j'ai oublié de le retirer. Je ne savais pas que les listes de lignes étaient autorisées, j'aurais dû lire les règles plus attentivement.


1
Pouvez-vous mettre en minuscule l'entrée pour éviter d'avoir à vérifier AZ ainsi que z et ensuite mod'ing?
streetster

@streetster Dans haskell, les fonctions toLower et toUpper nécessitent l'importation de Data.Char, ce qui coûte plus de caractères qu'il n'en sauvegarde. TIO
user1472751

1
Vous voudrez peut-être consulter les astuces pour jouer au golf à Haskell . Par exemple, if i>p c then ' ' else cpeut être raccourci à last$c:[' '|i>p c].
Laikoni

Deux autres choses: il y a un espace inutile dans [k | et le retour d’une liste de lignes est autorisé, vous n’avez donc pas besoin de unlines. Enfin, notre forum de discussion Haskell pourrait vous intéresser .
Laikoni

3

Excel VBA, 110 octets

Anonyme VBE Immediate Window Fonction qui prend en entrée le type attendu Variant\Stringde la plage [A1]et l'utilise pour faire pleuvoir l'alphabet dans la fenêtre immédiate de VBE.

?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next

Échantillon I / O

[A1]="qwertyuiop[]ASDFGHJKL:'zxcvbnm,./"
?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next
qwertyuiop[]ASDFGHJKL:'zxcvbnm,./
qwertyuiop   SDFGHJKL  zxcvbnm   
qwertyuiop   SDFGHJKL  zxcv nm   
qwertyuiop   SDFGHJKL  zx v nm   
qwertyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S  GHJKL  zx v nm   
qw rtyuiop   S   HJKL  zx v nm   
qw rtyuiop   S    JKL  zx v nm   
qw rtyu op   S    JKL  zx v nm   
qw rtyu op   S     KL  zx v nm   
qw rtyu op   S      L  zx v nm   
qw rtyu op   S         zx v nm   
qw rtyu op   S         zx v n    
qw rtyu op   S         zx v      
qw rtyu  p   S         zx v      
qw rtyu      S         zx v      
 w rtyu      S         zx v      
 w  tyu      S         zx v      
 w  tyu                zx v      
 w   yu                zx v      
 w   y                 zx v      
 w   y                 zx        
     y                 zx        
     y                 z         
                       z 

Brutal!!! Vous ?A1:...
semblez

@ LS_ᴅᴇᴠ, malheureusement, comme []indique que la chaîne contenue doit être évaluée en tant qu'objet dans / sur / comme classeur, l' [A1]appel ne peut pas être réduit à A1- car cela ne prendra ni n'imprimera l'entrée initiale de la plage [A1]; cela laissera plutôt une ligne vide et toutes les lignes suivantes seront imprimées
Taylor Scott

Ups, vous avez raison ... Je n'ai pas remarqué ça!
LS_ᴅᴇᴠ

3

PHP, 69 78 77 85 + 1 octets

for($c=A;!$c[1]&&~trim($s=&$argn);$s=eregi_replace("[^".++$c."-Z]"," ",$s))echo"$s
";

nécessite PHP <7. Exécuter en pipe -nRou essayer en ligne .


@Shaggy merci de nous l'avoir signalé. C'est complet maintenant.
Titus

+1 pour $c=A;!$c[1];$c++. Joli! Malheureusement extraneous trailing newlines are not allowed (single \n on final line is acceptable). Donc, il échoue pour toutes les chaînes ne contenant pas z.
Christoph

1
@Christoph fixe
Titus



2

Ruby, 70 67 74 octets

f=->s{puts s;(?b..?z).each{|c|s.gsub! /[^#{c}-z]/i,' ';puts s if s=~/\S/}}

Merci à @TuukkaX pour avoir signalé que certains parens pouvaient être supprimés (-3 octets)

Malheureusement, j'ai ensuite dû ajouter 7 octets, car la version d'origine ne gérait pas "z".

L'appelant:

f.call('The quick brown fox jumps over the lazy dog!')
The quick brown fox jumps over the lazy dog!
The quick brown fox jumps over the l zy dog
The quick  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy  og
Th  qui k  rown fox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  o
T   qui k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t     zy  o
T   qu     rown  ox  u ps ov r t     zy  o
T   qu     row   ox  u ps ov r t     zy  o
T   qu     r w    x  u ps  v r t     zy
T   qu     r w    x  u  s  v r t     zy
T    u     r w    x  u  s  v r t     zy
T    u       w    x  u  s  v   t     zy
T    u       w    x  u     v   t     zy
     u       w    x  u     v         zy
             w    x        v         zy
             w    x                  zy
                  x                  zy
                                     zy
                                     z

Les parenthèses dans la définition de lambda peuvent être supprimées. +1
Yytsi 10/10/17

2

Oracle SQL, 186 octets

Suppose que la chaîne sera dans une table ten colonne v:

WITH a(s,l)AS(SELECT v,64 FROM t UNION ALL SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1 FROM a WHERE l<90)SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)FROM a

Violon SQL

Configuration du schéma Oracle 11g R2 :

CREATE TABLE t ( v ) AS
SELECT '~|[abc<0>cba]|~' FROM DUAL
/

Requête 1 :

WITH a(s,l)AS(
  SELECT v,64 FROM t
UNION ALL
  SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1
  FROM a
  WHERE l<90
)
SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)
FROM a

Résultats :

|      LISTAGG(RTRIM(S),CHR(10))WITHINGROUP(ORDERBYL) |
|-----------------------------------------------------|
| ~|[abc<0>cba]|~                                     |
|    abc   cba                                        |
|     bc   cb                                         |
|      c   c                                          |


2

Haskell , 98 octets

p c=sum[length[a..c]|a:e<-["B[","b{"],[c]<e]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$p<$>s]]

Essayez-le en ligne!

Exemple d'utilisation: f "[Abc]"donne une liste de lignes:["[Abc]"," bc "," c "] . Utilisez putStr.unlines.f $ "[Abc]"pour une sortie joliment imprimée:

[Abc]
  avant JC
   c

Partiellement inspiré de Maintenant directement basé sur la réponse Haskell de user1472751 .


Approche précédente ( 100 99 octets)

f s=[h|i<-[0..26],h<-[[(c:concat[c<$[a..c]|[a,e]<-["B[","b{"],c<e]++cycle" ")!!i|c<-s]],any(>' ')h]

Essayez-le en ligne!


2

PowerShell , 122 127 octets

param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''

Essayez-le en ligne!

Court grâce à la façon dont PowerShell peut dynamiquement jeter entre [char]et[int] , mais long en raison de la suppression des blancs superflus et du calcul du caractère de sortie de l'espace ou du caractère.

Correction de bug grâce à beatcracker.


Malheureusement, cela échoue en ~|[abc<0>cba]|~cas de test. Essayez ceci:param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''
beatcracker

@beatcracker Bonne prise. C'est une façon intelligente de gérer la comparaison. Merci!
AdmBorkBork

2

Java 8, 151 147 144 143 139 octets

s->{String x="\n"+s;for(int i=64,t;++i<91;)for(char c:x.toCharArray())s+=(t=c&~32)>64&t<91&t>i|c<11?c:" ";return s.replaceAll("\\s+$","");}

Explication:

Essayez ici.

s->{                   // Method with String as both parameter and return-type
  String x="\n"+s;     //  Temp-String (equal to leading new-line + input)
  for(int i=64,        //  Index-integer `i` (starting at 64)
          t;           //  Temp-integer
      ++i<91;)         //  Loop (1) from 'A' (65) to 'Z' (90) (inclusive)
    for(char c:x.toCharArray())
                       //   Inner loop (2) over the character of the array
      s+=(t=c&~32)>64  //    If the current character as uppercase is larger than 'A'
         &t<91         //    and smaller or equal to 'Z'
         &t>i          //    and larger than the current index
         |c<11?        //    or the current character is a new-line
          c            //     Append the current character to `s`
         :             //    Else:
          " ";         //     Append a space to `s` instead
                       //   End of inner loop (2) (implicit / single-line body)
                       //  End of loop (1) (implicit / single-line body)
  return s             //  Return the result,
    .replaceAll("\\s+$",""); 
                       //   after we've removed all trailing spaces and new-lines
}                      // End of method

2

q , 42 37 octets

{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}

-5 grâce au streetster!


ancienne solution + explication:

{(+)max[m]$'(m:1+mod[.Q.a?lower x;26])#'x}


{                                        }  / lambda func
                     .Q.a?lower x           / get lowercase of input (ignores non-alpha values) and find (?) their index in "a...z" (.Q.a). non-alpha values return `26`
                 mod[.Q.a?lower x;26]       / get mod 26 of each index, this returns 0 where index is 26
            (m:1+mod[.Q.a?lower x;26])      / add 1 and assign to m
            (m:1+mod[.Q.a?lower x;26])#'x   / m and x conform, so we can take (#) m copies of each (') x at corresponding indices
    max[m]$'(m:1+mod[.Q.a?lower x;26])#'x   / get max of m, and pad each ($') of right-side list to that length
 (+)                                        / transpose the char matrix

1
{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}pour 37 ans, je ne me souviens plus de la façon dont j'ai résolu la question, probablement très similaire!
streetster

@streetster, merci! mis à jour. _Je ne savais pas à propos de k , j'ai saisi lowerl'interprète q et je l'ai obtenu k){$[~t&77h>t:abs@@x;.z.s'x;19<t;.z.s@. x;~t in 10 11h;'`type;_x]}. donnant donc ma réponse dans q haha
griffonner

1

SOGL V0.12 , 12 11 octets

ā,{Z⁴UW1Χ∙┼

Essayez-le ici!

Explication:

ā            push an empty array
 ,{          for each character in the input, pushing it
   Z           push the uppercase alphabet
    ⁴          push a duplicate of the character
     U         uppercase it
      W        find its index in that alphabet
       1Χ      get the maximum of that and 1
         ∙     repeat the character that many times
          ┼    append horizontally to that array
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.