Deletrea el Revu'a


16

En realidad, no está inspirado ni por Atbash Self Palindromes ni por la Calculadora de Gematria generalizada .

Dada una cadena s de longitud n , genera la secuencia Revu'a , que es el primer carácter de s , los dos primeros caracteres de s , ... los primeros n –2 caracteres de s , los primeros n –1 caracteres de s , todo el s .

La cadena solo constará de caracteres Unicode (cualquier codificación que desee) que tengan una fuerte direccionalidad y se encuentren en el rango de 0x0000 a 0xFFFF. Sin embargo, no se producirán caracteres de control de direccionalidad. Todos los caracteres en cualquier cadena dada tendrán la misma direccionalidad.

Puede regresar en notación de matriz ["t","te","tes","test"], como una cadena separada por espacios "t te tes test", como texto de varias líneas
t
te
tes
test
, una matriz preformateada

t
te
tes
prueba
o algo similar. Las cantidades de espacios iniciales, de separación y finales no son importantes, y tampoco lo son la nueva línea final. Pregunte si tiene dudas.

La entrada de derecha a izquierda debe dar como resultado una salida de derecha a izquierda en el orden correcto:
Entrada: "נחמן"
Salida: "נ נח נחמ נחמן"o

נ
נח
נחמ
נחמן
O ["נ","נח","נחמ","נחמן"]. Entre los resultados no válidos son "נחמן נחמ נח נ", "ן מן חמן נחמן"y "נחמן חמן מן ן".

Respuestas:


17

Dyalog APL, 2 bytes

,\

Reducción acumulativa por concatenar. Probarlo aquí .

El formato de la salida es más agradable cuando prefijas a , pero claramente muestra el orden correcto sin él.


2
Exactamente la misma solución funciona por la misma razón en K.
JohnE

@JohnE ¿K maneja Unicode?
Adám

12

JavaScript (ES6), 27 26 25 bytes

Guardado un byte gracias a @nicael y @ MartinBüttner, uno gracias a @Neil

x=>x.replace(/.?/g,"$` ")

Aprovecha algunas características integradas de la .replacefunción de JS . Específicamente, en el reemplazo, se $`convierte en todo lo que precede al carácter coincidente. Usar la expresión regular en /.?/glugar de /./gsignifica que también coincide con la cadena vacía al final.


Guardé otro byte: f=x=>x.replace(/.?/g,"$")`. Obtienes un espacio inicial adicional pero eso está permitido.
Neil

@Neil ¡Gracias, no tenía idea de que funcionaría!
ETHproductions

Ugh, olvidé citar mi `correctamente, pero veo que resolviste lo que quise decir.
Neil

6

Japt, 10 4 bytes

No me di cuenta de que una reducción acumulativa sería tan útil en este caso. :-)

UŒ+

Salidas como una matriz, separadas por comas por defecto. Si esto no está permitido, use este código de 6 bytes en su lugar:

U¬å+ ·

Pruébalo en línea!

Cómo funciona

      // Implicit: U = input string
U¬    // Split U into chars.
  å+  // Cumulative reduce: loop through each item in the array, concatenating it to the total.
      // ["t","e","s","t"] => ["t","te","tes","test"].
      // Implicit: output last expression

77
Está usando la frase "¡Pruébelo en línea!" y no enlazar a ¡ Pruébalo en línea! moralmente aceptable? : P
Martin Ender

3
@ MartinBüttner Había estado usando esa frase en las respuestas de Japt durante aproximadamente un mes antes de que Dennis la marcara. Siento que debería tener algún derecho moral para seguir usándolo: P
ETHproductions

6

Brainfuck, 40 bytes

Mi consola no admite caracteres de derecha a izquierda, pero no creo que funcione: c

++++++++++>,[>,]<[<]>[[<+>-]<[<]>[.>]>]

Sin golf:

++++++++++> # Store 10 (Newline)
,[>,]       # Store input
<[<]>       # Goto first character
[           # While next character
  [<+>-]    # Copy character to the left
  <[<]>     # Goto first character
  [.>]      # Print all charaters
  >         # Go to next character
]

13
Puede publicarlos como respuestas separadas.
nicael

20
Usted debe publicarlos como respuestas separadas.
Timwi

17
Usted debe publicarlos como respuestas separadas.
nicael

21
Usted SE publicarlos como respuestas separadas.
Timwi

11
Usted convencido a mí para publicarlos como respuestas separadas.
YoYoYonnY

5

Retina, 11 7 bytes

.
 $`$0

La salida está separada por espacios, con un espacio inicial y un avance de línea final.

Pruébalo en línea!


Para la posteridad, es portátil para Perl por 5 bytes más: perl -pE 's/./$$ & \ n / g ''. (Llego 11 meses tarde, lo sé)
Dada

4

Python, 35

f=lambda s:f(s[:-1])+[s]if s else[]

No se pudo encontrar una manera and/orde simplificar la recursión porque []es falsa.

Solución recursiva, devuelve una lista de cadenas.

Pruébalo en línea


4

Prólogo (SWI), 60 49 bytes

Código:

p(X):-findall(S,atom_prefix(X,S),[_|R]),write(R).

Explicado:

atom_prefix con X configurado como input y S como variable da 1 prefijo del átomo X que comienza con el átomo vacío.

Findall obtiene todas las soluciones y las coloca en una lista.

[_ | R] tira la cabeza (el átomo vacío) y almacena la cola en R

Ejemplos:

p('נחמן').
[נ, נח, נחמ, נחמן]

p('test').
[t, te, tes, test]

Pruébalo en línea aquí

Editar: salvó 11 bytes sólo almacenar la cola en R .



3

GNU Sed, 21

La puntuación incluye +1 para la -Eopción de sed:

:
s/^(\S+)\S/\1 &/
t

Funciona para LTR, pero no para RTL: me perdí ese bit. . En realidad se hace el trabajo, la RTL fue simplemente no prestando correctamente en mi terminal. Funciona bien con IO visto en un editor de texto sensible (por ejemplo, emacs). También funciona en Ideone:

Pruébalo en línea.


3

Brachylog , 5 bytes (no competidor)

@[@w\

Pruébalo en línea!

Explicación

@[       Take a prefix of the input
  @w     Write this prefix to STDOUT followed by a linebreak
    \    False: try another prefix

Las cadenas de derecha a izquierda parecen funcionar correctamente, aunque nunca las consideré.


¿Por qué no competir?
Adám

@ Adám @[y @wse implementaron necesariamente después de abril / mayo de 2016. Se podría encontrar la fecha exacta en las confirmaciones de Github, pero seguramente no antes de que se presente este desafío.
Fatalize

2

CJam, 9 bytes

l{N2$@+}*

La salida está separada por salto de línea.

Pruébalo aquí.

Explicación

l     e# Read input.
{     e# Fold this block over the input, which is effectively a foreach-loop which skips
      e# the first character...
  N   e#   Push a linefeed.
  2$  e#   Copy the previous string.
  @   e#   Pull up the current character.
  +   e#   Concatenate.
}*

Esperaba totalmente que CJam fuera más bajo que eso.
Timwi

@Timwi No hay una función incorporada "obtener todos los prefijos / sufijos" ni una función de orden superior para la acumulación generalizada, por lo que incluso si esto no es óptimo, dudo que pueda ser superado significativamente.
Martin Ender

Ll{+_p}/;tiene la misma duración, publicando porque no estoy seguro de si alguien con más experiencia podría jugar más al golf, y también tal vez arreglar las citas: P
FryAmTheEggman

2

JavaScript, 36 bytes

x=>[...x].map((c,i)=>x.slice(0,i+1))

Manifestación:

a=x=>[...x].map((c,i)=>x.slice(0,i+1));
document.write(
  a("test")+"<br>"+
  a("נחמן")
)

El principio es asignar y generar la porción de cadena desde el primer carácter a cada carácter de la palabra. Sorprendentemente, esto también funciona perfectamente para las cadenas RTL, no se necesita optimización.


2

Mi consola no admite caracteres de derecha a izquierda, pero no creo que funcione: c

C, 74 bytes (2da entrada)

char m[2<<9];i;main(){do{m[i]=getchar();printf("%s ",m);}while(m[i++]>0);}

Sin golf:

#include <stdio.h>

// char, because `printf("%s", str);` expects a array of characters.
char str[2<<9];
int  str_len = 0;
int main(void) {
    do {
        str[str_len]=getchar();
        printf("%s ", str);
    } while(m[i++]>0);
    return 0;
}

2

Mi consola no admite caracteres de derecha a izquierda, pero no creo que funcione: c

C, 105 bytes (3ª entrada)

m[2<<9];i;j;k;main(){while((m[i++]=getchar())<0);for(;j<i;j++,putchar(10))for(k=0;k<j;k++)putchar(m[k]);}

Sin golf:

#include <stdio.h>

int str[2<<9];
int str_len = 0;
int main(void) {
    do {
        str[str_len] = getchar();
    } while(str[str_len++] != EOF);
    int i;
    for(i=0; i<str_len; i++) {
        int j;
        for(j=0; j<i; j++) {
          putchar(str[j]);
        }
        putchar(10);
    }
}

2

TI-BASIC, 18 bytes

For(X,1,10^(9
Disp sub(Ans,1,X
End

No es técnicamente válido: TI-BASIC no es compatible con Unicode.

Nombra esto prgmAy escribe usando Ans.

La recursividad del programa sería más corta, pero no habría forma de inicializar las variables. Por lo tanto, mostramos una subcadena de la entrada en cada iteración. La entrada nunca se sobrescribe, ya que Disp no devuelve un valor.

Finalmente, el programa termina con un error después de imprimir la cadena completa.



2

Java 7, 95 92 bytes

String d(String a){for(int i=a.length();i-->0;a=a.substring(0,i)+(i>0?"\n":"")+a);return a;}

Respuesta anterior ( 95 bytes ):

String c(String s){String r="";for(int i=0;++i<=s.length();r+=s.substring(0,i)+"\n");return r;}

Intenté un enfoque recursivo, pero realmente no pude hacerlo funcionar. Quizás alguien más lo hará (más corto que este for-loop).

Sin golf y casos de prueba:

Pruébalo aquí

class M{
  static String d(String a){
    for(int i = a.length(); i-- > 0; a = a.substring(0, i) + (i > 0 ? "\n" : "") + a);
    return a;
  }

  public static void main(String[] a){
    System.out.println(c("test"));
    System.out.println();
    System.out.println(c("נחמן"));
  }
}

Salida:

t
te
tes
test

נ
נח
נחמ
נחמן

2

Dip , 1 byte (no competidor)

E

Explicación:

.   # Implicit input
 E  # Get prefixes
  . # Implicit print

Nunca he oído hablar de Dip.
Adám

@ Adám There ....
Oliver Ni

1

MATL , 8 bytes

Utiliza la versión actual (8.0.0) del lenguaje / compilador

jtn1X"YR

Ejemplo

>> matl
 > jtn1X"YR
 >
> test
t
te
tes
test

Explicación

j           % input string
tn          % duplicate and get length, say "N"
1X"         % repeat string N times vertically. Gives a char matrix
YR          % lower triangular part of matrix. Implicitly print


1

𝔼𝕊𝕄𝕚𝕟, 7 caracteres / 16 bytes

ᴉⓜᵖ ᵴ˖$

Try it here (Firefox only).

Probablemente hay un lugar para esto en alguna parte, simplemente no lo he encontrado.

Explicación

ᴉⓜᵖ ᵴ˖$ // implicit: ᴉ=split input, ᵴ=empty string
ᴉⓜ      // map over ᴉ
   ᵖ ᵴ˖$ // push ᵴ+=(mapped item char)
         // implicit stack output, separated by newlines

1

Javascript ES6, 29 bytes

(a,b='')=>[...a].map(x=>b+=x)

Esto no gana nada, pero es una solución simple.



1

Python, 32 bytes

f=lambda s:s and f(s[:-1])+" "+s

Función recursiva que genera una cadena separada por espacios con un espacio inicial.

Un programa de 34 bytes (Python 2):

s=""
for c in input():s+=c;print s

1

V , 5 bytes (no competitivos)

òÄ$xh

Pruébalo en línea!

Este lenguaje es más nuevo que el desafío, lo que hace que esta respuesta no sea competitiva. Explicación:

ò       " Recursively:
 Ä      "   Duplicate this line
  $     "   Move to the end of this line
   x    "   Delete one character
    h   "   Move one character to the right, which will throw an error when the line is one character long

1

PowerShell v2 +, 28 bytes

[char[]]$args[0]|%{($o+=$_)}

Toma datos $args[0], los charconvierte como una matriz, canaliza los caracteres en un bucle |%{...}. Cada iteración, acumulamos a $otravés +=del personaje actual $_. Esa expresión se encapsula en parens para que se coloque una copia en la tubería. Al final de la ejecución, la tubería se vacía mediante la Write-Outputcual se coloca una nueva línea entre los elementos.

PS C:\Tools\Scripts\golfing> .\spell-out-the-revua "נחמן"
נ
נח
נחמ
נחמן

PS C:\Tools\Scripts\golfing> .\spell-out-the-revua "PPCG"
P
PP
PPC
PPCG


Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.