Ajuster un mot dans une grille d'alphabet


55

Inspiré par un meme que j'ai vu plus tôt aujourd'hui.

Description du challenge

Considérons une grille infinie alphabet:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...

Prenez un mot ( CODEGOLFdans cet exemple) et faites-en une sous-séquence de la grille, en remplaçant les lettres inutilisées par un espace et en supprimant les lettres à la fin de la grille infinie:

  C           O           
   DE G       O           
           L              
     F

Exemples

STACKEXCHANGE

                  ST      
A C       K               
    E                  X  
  C    H                  
A            N            
      G                   
    E

ZYXWVUTSRQPONMLKJIHGFEDCBA

                         Z
                        Y 
                       X  
                      W   
                     V    
                    U     
                   T      
                  S       
                 R        
                Q         
               P          
              O           
             N            
            M             
           L              
          K               
         J                
        I                 
       H                  
      G                   
     F                    
    E                     
   D                      
  C                       
 B                        
A

F

     F

ANTIDISESTABLISHMENTARIANISM

A            N     T      
        I                 
   D    I         S       
    E             ST      
AB         L              
        I         S       
       H    M             
    E        N     T      
A                R        
        I                 
A            N            
        I         S       
            M

Remarques

  • Les espaces de fuite sont autorisés.
  • Vous n'avez pas besoin de remplir la dernière ligne avec des espaces. Par exemple, si l'entrée est ABC, vous pouvez générer uniquement ABCsans 23 espaces de fin.
  • Vous pouvez supposer que l'entrée correspondra à [A-Z]+regex.
  • Vous pouvez également utiliser un alphabet minuscule, auquel cas la sortie correspondra [a-z]+.
  • Vous devez utiliser une nouvelle ligne ( \n, \r\nou équivalent) à des lignes séparées, qui est une liste de chaînes n'est pas un format de sortie approprié.
  • Ceci est un défi de , alors faites votre code le plus court possible!

Les nouvelles lignes principales sont-elles autorisées?
Erik the Outgolfer

@EriktheOutgolfer Bien sûr, tant que cela ne perturbe pas la structure de la grille.
Shooqie

Serait-il possible qu'une erreur non fatale arrête le programme?
Zacharý

@ Zacharý Bien que je puisse voir comment cela pourrait économiser quelques octets, je pense que c'est moche et produit une sortie non souhaitée et superflue. Donc non. EDIT: sauf si vous pouvez faire en sorte que votre programme se ferme de manière non fatale via un code de sortie ou quelque chose qui n'imprimerait pas la trace de la pile des exceptions ou quelque chose de similaire à stderr.
Shooqie

7
Cas de test suggéré: BALLOON(deux caractères adjacents identiques).
Kevin Cruijssen

Réponses:


10

Coque , 15 octets

TṪS`?' €…"AZ"ġ>

Essayez-le en ligne!

Explication

TṪS`?' €…"AZ"ġ>  Implicit input, e.g. "HELLO"
             ġ>  Split into strictly increasing substrings: x = ["H","EL","LO"]
        …"AZ"    The uppercase alphabet (technically, the string "AZ" rangified).
 Ṫ               Outer product of the alphabet and x
  S`?' €         using this function:
                   Arguments: character, say c = 'L', and string, say s = "EL".
       €           1-based index of c in s, or 0 if not found: 2
  S`?'             If this is truthy, then c, else a space: 'L'
                 This gives, for each letter c of the alphabet,
                 a string of the same length as x,
                 containing c for those substrings that contain c,
                 and a space for others.
T                Transpose, implicitly print separated by newlines.

7

Java 10, 161 159 152 octets

s->{var x="";int p=0;for(var c:s)x+=p<(p=c)?c:";"+c;for(var y:x.split(";"))System.out.println("ABCDEFGHIJKLMNOPQRSTUVWXYZ".replaceAll("[^"+y+"]"," "));}

-2 octets grâce à @Nevay .
-7 octets imprimant directement au lieu de renvoyer une chaîne et de convertir en Java 10.

Explication: "

Essayez ici.

s->{                      // Method with String parameter and no return-type
  var x="";               //  Temp-String
  int p=0;                //  Previous character (as integer), starting at 0
  for(var c:s)            //  Loop (1) over the characters of the input
    x+=p<(p=c)?           //   If the current character is later in the alphabet
                          //   (replace previous `p` with current `c` afterwards)
        c                 //    Append the current character to Temp-String `x`
       :                  //   Else:
        ";"+c;            //    Append a delimiter ";" + this character to Temp-String `x`
  for(var y:x.split(";")) //  Loop (2) over the String-parts
    System.out.println(   //   Print, with trailing new-line:
     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          //    Take the alphabet,
        .replaceAll("[^"+y+"]"," "));}
                          //    and replace all letters not in the String-part with a space

La première partie de la méthode divise le mot d'entrée en plusieurs parties avec un délimiteur.
Par exemple: CODEGOLFCO;DEGO;L;Fou BALLOONB;AL;LO;O;N.

La deuxième partie boucle sur ces parties et utilise l'expression régulière [^...]pour remplacer tout ce qui ne correspond pas à un espace.
Par exemple, .replaceAll("[^CO]"," ")quitte le C, et O, et remplace tout le reste par un espace.


1
Ne serait-ce pas B;AL;LO;O;N?
NieDzejkob

1
-2 Octets for(char c:s)x+=p<(p=c)?c:";"+c;.
Nevay




4

JavaScript (ES6), 79

Modifier En tant que leader nouvelle ligne est acceptée, je peux économiser 2 octets

s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")

Pour 1 octet de plus, je peux accepter les entrées minuscules ou majuscules:

s=>eval("for(o='',v=i=0;c=s[i];v%=27)o+=v++?parseInt(c,36)-8-v?' ':s[i++]:`\n`")

Moins joué au golf

s=>{
  var i,o,c,v
  for(o = '', v = 1, i = 0; c = s.charCodeAt(i); v %= 27)
    o += v++ ? c-63-v ? ' ' : s[i++] : '\n'
  return o
}  

Tester

f=s=>eval("for(o='',v=i=0;c=s.charCodeAt(i);v%=27)o+=v++?c-63-v?' ':s[i++]:`\n`")

function update() {
  var i=I.value
  i=i.replace(/[^A-Z]/gi,'').toUpperCase()
  O.textContent=f(i)
}

update()
<input id=I value='BALLOON' oninput='update()' >
<pre id=O></pre>


Vous pouvez remplacer le \navec une nouvelle ligne littérale à l'intérieur des backticks pour -1 octet.
Justin Mariner

@JustinMariner Non, je ne peux pas, pas à l'intérieur de la double citation dans eval
edc65

Oh c'est vrai, c'est dommage. Ma faute.
Justin Mariner

4

MATL , 24 23 octets

''jt8+t1)wdh26X\Ys(26e!

Utilise des lettres minuscules.

Essayez-le sur MATL Online!

Explication

''     % Push empty string
jt     % Push input string. Duplicate
8+     % Add 8 to each char (ASCII code). This transforms 'a' 105,
       % 'b' into 106, which modulo 26 correspond to 1, 2 etc
t1)    % Duplicate. Get first entry
wd     % Swap. COnsecutive differences.
h      % Concatenate horizontally
26X\   % 1-based modulo 26. This gives a result from 1 to 26
Ys     % Cumulative sum
(      % Write values (converted into chars) at specified positions
       % of the initially empty string
26e    % Reshape into a 26-row char matrix, padding with char 0
!      % Transpose. Implicitly display. Char 0 is shown as space

4

Japt , 18 16 octets

-2 octets grâce à @Shaggy

;ò¨ £B®kX ?S:Z
·

Entrée en majuscule seulement.

Essayez-le en ligne!

Explication

;

Basculer vers des variables alternatives, où Best l'alphabet majuscule.

ò¨

Fractionner la chaîne d'entrée entre des caractères lorsque le premier est supérieur ou égal à ( ¨) le second.

£

Mappez chaque partition par la fonction, où Xest la partition actuelle.

Mappez chaque caractère de l'alphabet majuscule sur le suivant, avec Zla lettre actuelle.

kX

Supprime toutes les lettres de la partition actuelle de la lettre actuelle. Si la lettre en cours est contenue dans la partition en cours, il en résulte une chaîne vide.

?S:Z

Si cela est vrai (pas une chaîne vide), retournez un espace ( S), sinon, retournez la lettre courante.

·

Joignez le résultat de la ligne précédente avec des nouvelles lignes et imprimez le résultat.


10 octets pour r"[^{Z}]"Ssemblent un peu ridicules, mais je ne trouve pas de meilleur moyen non plus ...
ETHproductions



@Shaggy Bonne pensée avec kX!
Justin Mariner

En fait, je pense que vous pouvez changer kX ?S:Zpour oX ªSéconomiser deux octets
ETHproductions


3

Gelée , 19 octets

<2\¬0;œṗfȯ⁶$¥€@€ØAY

Essayez-le en ligne!


OI<1®;-> >2\0;pour économiser un octet (j'ai en fait fait aussi >2\0;œṗµØAf€ȯ€⁶µ€Ypour 18, ce que je trouve personnellement plus facile à analyser)
Jonathan Allan

@ JonathanAllan Je pense que cela échouerait pour BALLOONquelque chose.
Erik the Outgolfer

Vous avez raison, oui - il faudrait donc un autre octet avec quelque chose comme <2\1;¬; tant pis.
Jonathan Allan

@ JonathanAllan Quoi qu'il en soit, je vais mettre en œuvre votre idée dans ma réponse ... fait.
Erik the Outgolfer

3

C (gcc), 91 63 octets

-28 grâce à ASCII uniquement

_;f(char*s){for(_=64;*s;)putchar(++_>90?_=64,10:*s^_?32:*s++);}

Essayez-le en ligne!


Précédent:

i,j;f(char*s){while(s[i]){for(j=65;j<91;j++)s[i]==j?putchar(s[i++]):printf(" ");puts("");}}

Oui, il y a une solution plus courte, mais j'ai remarqué après avoir écrit celle-ci ... Essayez-la en ligne!


82 octets , 80 si la nouvelle ligne principale est autorisée
ASCII uniquement



3

Mathematica, 101 octets

StringRiffle[
  Alphabet[]/.#->" "&/@
   (Except[#|##,_String]&@@@
     Split[Characters@#,#==1&@*Order]),"
",""]&

Splitl’entrée dans des séquences de lettres strictement croissantes, en comparant des lettres adjacentes avec Order. Si Order[x,y] == 1, alors xprécède ydans l'alphabet et peut donc apparaître sur la même ligne.

Pour chaque séquence de lettres, créez un motif pour faire correspondre les chaînes Exceptde ces lettres; #|##est un raccourci pour Alternatives. Remplacez les lettres Alphabetqui correspondent au motif par des espaces.


Illustration des étapes intermédiaires:

"codegolf";
Split[Characters@#,#==1&@*Order]  &@%
Except[#|##,_String]&@@@         #&@%
Alphabet[]/.#->" "&/@               %
{{"c", "o"}, {"d", "e", "g", "o"}, {"l"}, {"f"}}

{Except["c" | "c" | "o", _String], 
 Except["d" | "d" | "e" | "g" | "o", _String], 
 Except["l" | "l", _String],
 Except["f" | "f", _String]}

{{" "," ","c"," "," "," "," "," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," ","d","e"," ","g"," "," "," "," "," "," "," ","o"," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," "," "," "," "," "," "," ","l"," "," "," "," "," "," "," "," "," "," "," "," "," "," "},
 {" "," "," "," "," ","f"," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "}}

2

Golfscript, 22 21 octets

Essayez-le en ligne!

-1 octet grâce à une redéfinition finale de l’ nintégré.

{.n>{}{'
'\}if:n}%:n;

Explication (avec une version légèrement différente):

{.n>{}{"\n"\}if:n}%:n; # Full program
{                }%    # Go through every character in the string
 .n>         if        # If ASCII code is greater than previous...
                       # (n means newline by default, so 1st char guaranteed to fit)
    {}                 # Do nothing
      {"\n"\}          # Else, put newline before character
               :n      # Redefine n as the last used character
                   :n; # The stack contents are printed at end of execution
                       # Literally followed by the variable n, usually newline
                       # So because n is by now an ASCII code...
                       # ...redefine n as the new string, and empty the stack

2

Retina , 80 octets

^
;¶
{`;.*
¶;ABCDEFGHIJKLMNOPQRSTUVWXYZ
¶¶
¶
)+`;(.*)(.)(.*¶)\2
$.1$* $2;$3
;.*

Essayez-le en ligne!

Il y a toujours exactement une nouvelle ligne principale. Le code préfixe légèrement le mot avec l'alphabet et un marqueur (point-virgule). Il déplace ensuite le marqueur jusqu'à la première lettre du mot, tout en modifiant toutes les autres lettres, il passe aux espaces. Il supprime également la première lettre du mot. Il répète ceci jusqu'à ce que la première lettre du mot ne soit plus après le marqueur. Ensuite, il efface ce marqueur et le reste de l'alphabet et le remplace par une nouvelle ligne et l'alphabet par un marqueur à nouveau. Il répète cette opération jusqu'à ce que le mot saisi soit vide, puis nettoie le dernier alphabet et le dernier marqueur, en laissant la sortie souhaitée.


2

05AB1E , 18 octets

ćIgµ¶?AvDyÊið?ë¼?ć

Essayez-le en ligne!

Problème rencontré avec 05AB1E ć(extrait 1) en laissant une chaîne / liste vide sur la pile après l'extraction du dernier élément. Si ce n’était pas le cas, cette solution serait plus courte de 1 à 2 octets.

ćIgµ¶?AvDyÊið?ë¼?ć  Implicit input 
ć                   Extract the 1st char from the string
 Igµ                While counter != length of the string
    ¶?              Print a newline
      Av            For each letter of the lowercased alphabet
        DyÊ         Is the examined character different from the current letter?
           ið?      If true, then print a space

              ë¼?ć  Else increment the counter, print the letter and push
                    the next character of the string on the stack

En fait, ð,signifie "imprimer un espace et une nouvelle ligne".
Erik the Outgolfer

Vous avez raison. Correction du code pour réellement imprimer une nouvelle ligne.
scottinet

2

Retina , 130 126 octets

$
¶A
{-2=`
$'
}T`RL`_o`.$
+`(?<=(.)*)((.).*¶(?<-1>.)*(?(1)(?!)).+\3.*$)
 $2
(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2
}`¶.*$

Essayez-le en ligne! Edit: 4 octets enregistrés à l’aide du générateur d’alphabet de @ MartinEnder. Explication:

$
¶A
{-2=`
$'
}T`RL`_o`.$

Ajouter l'alphabet.

+`(?<=(.)*)((.).*¶(?<-1>.)*(?(1)(?!)).+\3.*$)
 $2

Alignez autant de lettres que possible avec leur position dans l'alphabet.

(?<=(.)*)((.).*¶(?<-1>.)*(?<-1>\3.*$))
¶$2

Commencez une nouvelle ligne avant la première lettre qui n'a pas pu être alignée.

}`¶.*$

Supprimez l'alphabet, puis recommencez jusqu'à ce qu'il n'y ait plus de lettres mal alignées.


Cela ne semble imprimer qu'une seule ligne, sans aligner les lettres sur les lignes suivantes.
Justin Mariner

@JustinMariner Mon mauvais, j'ai fait une faute de frappe dans mon dernier golf et n'a pas réussi à vérifier correctement.
Neil

2

q / kdb + , 48 45 octets

Solution:

-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:;

Essayez-le en ligne!

Remarque: Link est relié à un port K (oK) de cette solution car il n'y a pas de TIO pour q / kdb +.

Exemples:

q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"STACKEXCHANGE";
                  ST
A C       K
    E                  X
  C    H
A            N
      G
    E

q)-1{@[26#" ";.Q.A?x;:;x]}@/:(0,(&)(<=':)x)_x:"BALLOON";
 B
A          L
           L  O
              O
             N

Explication:

Q est interprété de droite à gauche. La solution est divisée en deux parties. Commencez par diviser la chaîne lorsque le caractère suivant est inférieur ou égal à la valeur actuelle:

"STACKEXCHANGE" -> "ST","ACK","EX","CH","AN","G","E"

Prenez ensuite une chaîne de 26 espaces vierges et appliquez-la aux index où l'entrée apparaît dans l'alphabet, puis imprimez sur la sortie standard.

"__________________________" -> __________________ST______

Panne:

-1{@[26#" ";.Q.A?x;:;x]}each(0,where (<=':)x) cut x:; / ungolfed solution
-1                                                  ; / print to stdout, swallow return value
                                                  x:  / store input as variable x
                                              cut     / cut slices x at these indices
                            (               )         / do this together
                                     (<=':)x          / is current char less-or-equal (<=) than each previous (':)?
                               where                  / indices where this is true
                             0,                       / prepended with 0
                        each                          / take each item and apply function to it
  {                    }                              / lambda function with x as implicit input
   @[      ;      ; ; ]                               / apply[variable;indices;function;arguments]
     26#" "                                           / 26 take " " is "      "...
            .Q.A?x                                    / lookup x in the uppercase alphabet, returns indice(s)
                   :                                  / assignment
                     x                                / the input to apply to these indices

Remarques:

  • -3 octets en remplaçant prev par la version K4

2

Powershell, 70 à 63 octets

-7 octets merci @Veskah

$args|%{if($_-le$p){$x;rv x}
$x=("$x"|% *ht($_-65))+($p=$_)}
$x

Essayez-le en ligne!

Explication:

Pour chaque caractère de l'argument splatté:

  • Chaîne de sortie $xet $xvaleur vide ( rvalias pour Remove-Variable ), si le code du caractère en cours est inférieur ou équivalent ( -le) à un code du caractère précédent.
  • Ajoutez des espaces et le caractère actuel à $x, stockez-le dans $x. En outre, il rafraîchit une valeur de caractère précédente.

Sortie en dernier $x.


1
63 octets en utilisant splatting . J'ai essayé d'utiliser |% *htpour sauver quelques octets, mais on dirait qu'il a fait ses frais.
Veska



1

JavaScript (ES6), 87 octets

f=([...s])=>s[0]?(g=i=>i>35?`
`+f(s):(i-parseInt(s[0],36)?" ":s.shift())+g(i+1))(10):""

Accepte les majuscules ou les minuscules. La sortie correspond à la casse de l'entrée.

Des tests


1

Haskell, 81 74 73 octets

q@(w:y)!(x:z)|w==x=x:y!z|1<2=min ' 'x:q!z
x!_=x
a=['A'..'Z']++'\n':a
(!a)

Sauvé 1 octet grâce à Laikoni !

Essayez-le en ligne.

Optimisations de Haskell Hugs

  1. L'interpréteur Hugs me permet de sauvegarder un octet de plus en faisant (!cycle$['A'..'Z']++"\n")plutôt (!cycle(['A'..'Z']++"\n"))que :, mais GHC n'aime pas le précédent . (Ceci est maintenant obsolète; Laikoni a déjà réécrit cette ligne de manière à économiser 1 octet.)

  2. Apparemment, Hugs n’exige pas non plus de parenthèses autour de la liste des motifs de liste, ce qui me permet de sauvegarder deux octets supplémentaires allant de: q@(w:y)!(x:z)à q@(w:y)!x:z.


Vous pouvez enregistrer un octet avec a=['A'..'Z']++'\n':a;(!a). Il est intéressant de noter que Hugs semble avoir des règles plus laxistes.
Laikoni

@ Laikoni Je regarde Haskell depuis des mois et cela ne cesse de m'étonner. J'aime le a=...:atruc. Merci!
Cristian Lupascu

Je ne sais pas si vous êtes au courant, mais je pense que cela mérite d'être mentionné. La raison pour laquelle Hugs est différent ici est qu’il existe une priorité moindre pour les opérateurs définis par l’utilisateur que pour le ghc.
Wheat Wizard

@ WheatWizard je n'étais pas au courant. Cela est parfaitement logique, compte tenu de l'erreur que j'ai commise dans GHC.
Cristian Lupascu



1

Charbon de bois , 15 octets

Fθ«J⌕αι⁺ⅉ‹⌕αιⅈι

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

 θ              Input string
F «             Loop over characters
     α     α    Uppercase letters predefined variable
      ι     ι   Current character
    ⌕     ⌕     Find index
             ⅈ  Current X co-ordinate
         ‹      Compare
        ⅉ       Current Y co-ordinate
       ⁺        Sum
   J            Jump to aboslute position
              ι Print current character


1

K (ngn / k) , 29 28 octets

{{x@x?`c$65+!26}'(&~>':x)_x}

Essayez-le en ligne!

{ } fonction avec argument x

>':x pour chaque personnage, est-il supérieur au précédent?

~ nier

& où (à quels indices) avons-nous vrai

( )_xcouper xà ces index, retourne une liste de chaînes

{ }' pour chacune de ces chaînes

`c$65+!26

L'alphabet anglais

x?trouver l'index de la première occurrence de chaque lettre en x, utilisez 0N(une valeur "nulle" spéciale) si non trouvé

x@index xavec ça; indexation avec des 0Nretours " ", nous obtenons donc une chaîne de longueur 26 dans laquelle les lettres xsont à leur position alphabétique et tout le reste est constitué d'espaces


1

R , 129 117 octets

function(s){z={}
y=diff(x<-utf8ToInt(s)-64)
z[diffinv(y+26*(y<0))+x[1]]=LETTERS[x]
z[is.na(z)]=" "
write(z,1,26,,"")}

Essayez-le en ligne!

Explication (non golfée):

function(s){
 z <- c()                  # initialize an empty vector
 x <- utf8ToInt(s)-64      # map to char code, map to range 1:26
 y <- diff(x)              # successive differences of x
 idx <- cumsum(c(          # indices into z: cumulative sum of:
    x[1],                  # first element of x
    ifelse(y<=0,y+26,y)))  # vectorized if: maps non-positive values to themselves + 26, positives to themselves
 z[idx] <- LETTERS[x]      # put letters at indices
 z[is.na(z)] <- " "        # replace NA with space
 write(z,"",26,,"")        # write z as a matrix to STDOUT ("") with 26 columns and empty separator.

1

R , 95 octets

Parcourez simplement l'alphabet majuscule de manière répétée en faisant avancer d'un compteur de 1 si vous rencontrez la lettre dans la position de compteur du mot et en imprimant la lettre, sinon un espace.

function(s)while(F>""){for(l in LETTERS)cat("if"((F=substr(s,T,T))==l,{T=T+1;l}," "));cat("
")}

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.