Encajar una palabra en una cuadrícula del alfabeto

55

Inspirado en un meme que vi hoy más temprano.

Descripción del desafío

Considere una cuadrícula de alfabeto infinito:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
...

Tome una palabra ( CODEGOLFen este ejemplo) y conviértala en una subsecuencia de la cuadrícula, reemplazando las letras no utilizadas por un espacio y eliminando las letras al final de la cuadrícula infinita por completo:

  C           O           
   DE G       O           
           L              
     F

Ejemplos

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

Notas

  • Se permiten espacios en blanco al final.
  • No necesita rellenar la última línea con espacios. Por ejemplo, si la entrada es ABC, puede salir ABCsin 23 espacios finales.
  • Puede suponer que la entrada coincidirá con la [A-Z]+expresión regular.
  • Alternativamente, puede usar el alfabeto en minúsculas, en cuyo caso la salida coincidirá [a-z]+.
  • Se debe utilizar una nueva línea ( \n, \r\no equivalente) a las líneas separadas, que es una lista de cadenas no es un formato de salida adecuado.
  • Este es un desafío de , ¡así que haga su código lo más corto posible!
shooqie
fuente
¿Se permiten nuevas líneas principales?
Erik the Outgolfer
@EriktheOutgolfer Claro, siempre que no estropee la estructura de la cuadrícula.
shooqie
¿Estaría bien si un error no fatal detiene el programa?
Zacharý
@ Zacharý Aunque puedo ver cómo eso podría ahorrar algunos bytes, creo que es feo y produce resultados no deseados y superfluos. Entonces no. EDITAR: a menos que pueda hacer que su programa salga de manera no fatal a través de un código de salida o algo que no imprima el seguimiento de la pila de excepciones o algo similar a stderr.
shooqie
77
Caso de prueba sugerido: BALLOON(dos caracteres adyacentes que son iguales).
Kevin Cruijssen

Respuestas:

10

Casco , 15 bytes

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

Pruébalo en línea!

Explicación

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.
Zgarb
fuente
7

Java 10, 161 159 152 bytes

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 bytes gracias a @Nevay .
-7 bytes de impresión directamente en lugar de devolver una Cadena y convertir a Java 10.

Explicación: "

Pruébalo aquí

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 primera parte del método divide la palabra de entrada en partes con un delimitador.
Por ejemplo: CODEGOLFCO;DEGO;L;Fo BALLOONB;AL;LO;O;N.

La segunda parte recorre estas partes y usa la expresión regular [^...]para reemplazar todo lo que no coincide con un espacio.
Por ejemplo, .replaceAll("[^CO]"," ")deja el C, y O, y reemplaza todo lo demás con un espacio.

Kevin Cruijssen
fuente
1
¿No sería así B;AL;LO;O;N?
NieDzejkob
1
-2 Bytes: for(char c:s)x+=p<(p=c)?c:";"+c;.
Nevay
4

Perl 5 , 44 bytes

Código de 40 bytes + 4 para -lF.

print map/$F[0]/?shift@F:$",A..Z while@F

Pruébalo en línea!

Dom Hastings
fuente
El enlace que ha publicado es para la versión de 46 bytes.
@ThePirateBay ¡Gracias! ¡Sabía que no había actualizado algo!
Dom Hastings
4

JavaScript (ES6), 79

Editar Como se acepta una nueva línea principal, puedo guardar 2 bytes

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

Por 1 byte más, puedo aceptar entradas en minúsculas o mayúsculas:

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

Menos 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
}  

Prueba

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>

edc65
fuente
Puede reemplazar el \ncon una nueva línea literal dentro de los backticks para -1 byte.
Justin Mariner
@JustinMariner no, no puedo, no dentro de la cita doble en eval
edc65
Oh cierto, es una pena. Culpa mía.
Justin Mariner
4

MATL , 24 23 bytes

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

Utiliza letras minúsculas.

¡Pruébalo en MATL Online!

Explicación

''     % 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
Luis Mendo
fuente
4

Japt , 18 16 bytes

-2 bytes gracias a @Shaggy

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

Entrada en mayúscula solamente.

Pruébalo en línea!

Explicación

;

Cambie a variables alternativas, donde Bestá el alfabeto en mayúsculas.

ò¨

Divida la cadena de entrada entre caracteres donde el primero es mayor o igual que ( ¨) el segundo.

£

Asigne cada partición por la función, donde Xestá la partición actual.

Asigna cada carácter del alfabeto en mayúscula a lo siguiente, Zsiendo la letra actual.

kX

Elimina todas las letras de la partición actual de la letra actual. Si la letra actual está contenida en la partición actual, esto da como resultado una cadena vacía.

?S:Z

Si eso es verdad (no una cadena vacía), devuelve un espacio ( S), de lo contrario devuelve la letra actual.

·

Une el resultado de la línea anterior con nuevas líneas e imprime el resultado.

Justin Mariner
fuente
10 bytes para r"[^{Z}]"Sparece un poco ridículo, pero tampoco puedo encontrar una mejor manera ...
ETHproductions
17 bytes
Shaggy
16 bytes
Shaggy
@Shaggy ¡Buen pensamiento con kX!
Justin Mariner
En realidad, creo que puede cambiar kX ?S:Zpara oX ªSguardar dos bytes
ETHproductions
3

Pyth, 18 bytes

#pbVGp?JqhzNNd=>zJ

Pruébalo aquí

Nueva línea inicial en salida, alfabeto en minúsculas.

Erik el Outgolfer
fuente
3

Jalea , 19 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente
OI<1®;-> >2\0;para guardar un byte (en realidad también lo hice >2\0;œṗµØAf€ȯ€⁶µ€Ypara 18, lo que personalmente me parece más fácil de analizar)
Jonathan Allan
@ JonathanAllan Creo que eso podría fallar BALLOONo algo así.
Erik the Outgolfer
Tienes razón, sí, por lo que requeriría otro byte con algo como <2\1;¬; Oh bien.
Jonathan Allan
@JonathanAllan De todos modos, implementaré tu idea en mi respuesta ... hecho.
Erik the Outgolfer
3

C (gcc), 91 63 bytes

-28 gracias a ASCII-only

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

Pruébalo en línea!


Anterior:

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

Sí, hay una solución más corta, pero me di cuenta después de escribir esta ... ¡ Pruébelo en línea!

MD XF
fuente
82 bytes , 80 si se permite una nueva línea principal
solo ASCII el
73
Solo ASCII
63
Solo ASCII
3

Mathematica, 101 bytes

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

Splitla entrada en secuencias de letras estrictamente crecientes, comparando letras adyacentes con Order. Si Order[x,y] == 1, entoncesx precede yal alfabeto y, por lo tanto, puede aparecer en la misma línea.

Para cada secuencia de letras, cree un patrón para que coincida con las cadenas Exceptde esas letras; #|##es una abreviatura de Alternatives. Reemplace las letras Alphabetque coinciden con el patrón con espacios.


Ilustración de los pasos intermedios:

"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"," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "," "}}
hftf
fuente
2

Golfscript, 22 21 bytes

Pruébalo en línea!

-1 byte gracias a la cuidadosa redefinición final del nincorporado.

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

Explicación (con una versión ligeramente diferente):

{.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
Josiah Winslow
fuente
2

Retina , 80 bytes

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

Pruébalo en línea!

Siempre hay exactamente una nueva línea principal. El código un poco torpemente antepone la palabra con el alfabeto junto con un marcador (punto y coma). Luego mueve el marcador hasta la primera letra de la palabra, mientras cambia todas las demás letras que pasa a espacios. También elimina la primera letra de la palabra. Repite esto hasta que la primera letra de la palabra ya no esté detrás del marcador. Luego borra ese marcador y el resto del alfabeto, y lo reemplaza con una nueva línea y el alfabeto con un marcador nuevamente. Sigue repitiendo esto hasta que la palabra de entrada esté vacía, luego limpia el último alfabeto y marcador, dejando la salida deseada.

FryAmTheEggman
fuente
2

05AB1E , 18 bytes

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

Pruébalo en línea!

Tengo problemas con 05AB1E ć(extracto 1) dejando una cadena / lista vacía en la pila después de extraer el último elemento. Esta solución sería 1-2 bytes más corta si no fuera por eso.

ć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
scottinet
fuente
En realidad, ð,significa "imprimir un espacio y una nueva línea".
Erik the Outgolfer
Tienes razón. Se corrigió el código para imprimir realmente una nueva línea.
scottinet
2

Retina , 130 126 bytes

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

Pruébalo en línea! Editar: Guardado 4 bytes usando el generador de alfabeto de @ MartinEnder. Explicación:

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

Añade el alfabeto.

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

Alinee tantas letras como sea posible con su posición en el alfabeto.

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

Comience una nueva línea antes de la primera letra que no se pudo alinear.

}`¶.*$

Elimine el alfabeto, pero luego haga todo de nuevo hasta que no haya letras desalineadas.

Neil
fuente
Esto parece imprimir solo una línea, no alineando letras en líneas posteriores.
Justin Mariner
@JustinMariner Lo malo es que cometí un error tipográfico en mi último golf y no pude comprobarlo correctamente.
Neil
2

q / kdb + , 48 45 bytes

Solución:

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

Pruébalo en línea!

Nota: El enlace es a una K (oK) puerto de esta solución ya que no hay TIO para q / kdb +.

Ejemplos:

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

Explicación:

Q se interpreta de derecha a izquierda. La solución se divide en dos partes. Primero divida la cadena donde el siguiente carácter es menor o igual que el actual:

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

Luego tome una cadena de 26 espacios en blanco y aplique la entrada en los índices donde la entrada aparece en el alfabeto, e imprima en stdout.

"__________________________" -> __________________ST______

Descompostura:

-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

Notas:

  • -3 bytes reemplazando prev con la versión K4
callejero
fuente
2

Powershell, 70 63 bytes

-7 bytes gracias @Veskah

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

Pruébalo en línea!

Explicación:

Para cada personaje en el argumento salpicado:

  • Cadena de salida $xy $xvalor claro ( rves alias para Remove-Variable ), si un código del carácter actual es menor o equivalente (-le ) a un código del carácter anterior.
  • Agregue espacios y el carácter actual a $x, almacénelo en $x. También refresca un valor de carácter anterior.

Salida al final $x.

mazzy
fuente
1
63 Bytes usando salpicaduras . Intenté usarlo |% *htpara guardar algunos bytes pero parece que no funcionó.
Veskah
1

Jalea , 24 21 bytes

3 bytes gracias a Erik the Outgolfer.

O64;I%26’⁶ẋЀ;"⁸Ẏs26Y

Pruébalo en línea!

Monja permeable
fuente
8
Creo que esto falla para la entrada "GLOBO": los caracteres repetidos están en la misma línea.
Justin Mariner
1

JavaScript (ES6), 87 bytes

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

Acepta entradas en mayúsculas o minúsculas. La salida coincide con el caso de la entrada.

Pruebas

Justin Mariner
fuente
1

Haskell, 81 74 73 bytes

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

¡Guardado 1 byte gracias a Laikoni !

Pruébalo en línea.

Optimizaciones de Haskell Hugs

  1. El intérprete de Hugs me permite guardar un byte más haciendo en (!cycle$['A'..'Z']++"\n")lugar de: (!cycle(['A'..'Z']++"\n"))pero a GHC no le gusta el primero . (Esto ahora es obsoleto; Laikoni ya reescribió esa línea de una manera que ahorró 1 byte).

  2. Aparentemente, Hugs tampoco requiere paréntesis alrededor del patrón de lista, por lo que podría guardar dos bytes más yendo de: q@(w:y)!(x:z)a q@(w:y)!x:z.

Cristian Lupascu
fuente
Puede guardar un byte con a=['A'..'Z']++'\n':a;(!a). Interesante ahora que Hugs parece tener reglas algo más laxas.
Laikoni
@Laikoni Estoy mirando a Haskell desde hace meses y no deja de sorprenderme. Me encanta el a=...:atruco ¡Gracias!
Cristian Lupascu
No sé si es consciente de esto, pero creo que vale la pena mencionarlo. La razón por la que Hugs es diferente aquí es que hay una menor prioridad de operador para operadores definidos por el usuario que en el ghc.
Wheat Wizard
@WheatWizard No estaba al tanto. Esto tiene mucho sentido, dado el error que obtuve en GHC.
Cristian Lupascu
1

Carbón de leña , 15 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 θ              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
Neil
fuente
1

K (ngn / k) , 29 28 bytes

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

Pruébalo en línea!

{ } funcionar con argumento x

>':x para cada personaje, ¿es mayor que el personaje anterior?

~ negar

& ¿Dónde (en qué índices) tenemos verdad

( )_xcortar xesos índices, devolver una lista de cadenas

{ }' para cada una de esas cuerdas

`c$65+!26

el alfabeto inglés

x?encuentre el índice de la primera aparición de cada letra x, use 0N(un valor "nulo" especial) si no se encuentra

x@indice xcon eso; indexación con 0Nretornos " ", por lo que obtenemos una cadena de longitud 26 en la que las letras xestán en sus posiciones alfabéticas y todo lo demás son espacios

ngn
fuente
1

R , 129117 bytes

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,,"")}

Pruébalo en línea!

Explicación (sin golf):

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.
Giuseppe
fuente
1

R , 95 bytes

Simplemente recorra el alfabeto en mayúsculas repetidamente mientras avanza un contador en 1 si encuentra la letra en la posición del contador de la palabra e imprime la letra, un espacio en caso contrario.

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

Pruébalo en línea!

J.Doe
fuente
1

GolfScript , 37 bytes

64:a;{.a>{}{'
'\64:a;}if.a-(' '*\:a}%

Pruébalo en línea!

Hice un Golfscript con un nombre diferente, pero tenía una salida incorrecta.

JosiahRyanW
fuente