Imprimeme una escala

20

¡Oh no! ¡Tengo un examen teórico pronto y todavía no recuerdo las escalas! Ayúdame a recordar mis escalas principales imprimiendo lo siguiente:

7♯ - C♯ D♯ E♯ F♯ G♯ A♯ B♯ C♯
6♯ - F♯ G♯ A♯ B  C♯ D♯ E♯ F♯
5♯ - B  C♯ D♯ E  F♯ G♯ A♯ B
4♯ - E  F♯ G♯ A  B  C♯ D♯ E
3♯ - A  B  C♯ D  E  F♯ G♯ A
2♯ - D  E  F♯ G  A  B  C♯ D
1♯ - G  A  B  C  D  E  F♯ G
0  - C  D  E  F  G  A  B  C
1♭ - F  G  A  B♭ C  D  E  F
2♭ - B♭ C  D  E♭ F  G  A  B♭
3♭ - E♭ F  G  A♭ B♭ C  D  E♭
4♭ - A♭ B♭ C  D♭ E♭ F  G  A♭
5♭ - D♭ E♭ F  G♭ A♭ B♭ C  D♭
6♭ - G♭ A♭ B♭ C♭ D♭ E♭ F  G♭
7♭ - C♭ D♭ E♭ F♭ G♭ A♭ B♭ C♭

Este es el código de golf, por lo que gana el código más corto. Puede usar símbolos #y en blugar de y respectivamente.

Editar: si está utilizando signos y , solo tiene que contarlos como un solo byte cada uno. Esto es para no dar una desventaja injusta.

ericw31415
fuente
1
¿Es aceptable una nueva línea líder en la salida?
Steadybox
44
¡No puedo creer que todavía no haya una respuesta de Fugue !
leo
¿Cuán estricto es el formato de salida? ¿Podemos superar una serie de líneas? ¿Qué tal una matriz 2D con cada elemento como una sola nota o personaje?
Shaggy
@ Shaggy No sé cuál es el estándar para las preguntas de complejidad de Kolmogorov, así que diré que no.
ericw31415
3
: tanto por las fuentes monoespaciales en elementos de código
Chiel ten Brinke

Respuestas:

8

Carbón de leña , 66 65 bytes (si usa # yb)

↑⮌…0¦8‖O⸿×⁷♭M→×⁷♯→⸿⸿¹⁵FE⁸﹪⊕⊗ι⁷«⸿⸿✂׳FCGDAEBι⁺¹⁵ι→⸿✂⭆♭ ♯×⁷κι⁺¹⁵ι»⟲

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

↑⮌…0¦8‖O

Imprima los caracteres 0al 7revés, luego reflexione con superposición. Las listas normalmente se imprimen hacia abajo, por lo que imprimir hacia arriba en realidad se imprime hacia la derecha; rotaremos todo en su lugar al final.

⸿×⁷♭M→×⁷♯

Comience una nueva línea e imprima 7 planos y 7 objetos punzantes con un espacio intermedio.

→⸿⸿¹⁵

Deje una línea en blanco e imprima 15 -s.

FE⁸﹪⊕⊗ι⁷«

Tome los números del 0 al 7, duplíquelos, agregue 1, luego reduzca el módulo 7. Pase el resultado.

⸿⸿✂׳FCGDAEBι⁺¹⁵ι

Deje una línea en blanco y luego tome una porción de 15 caracteres de la cadena de notas triplicada comenzando en el valor actual.

→⸿✂⭆♭ ♯×⁷κι⁺¹⁵ι

En la línea siguiente, tome un segmento de pisos, espacios y objetos punzantes de 15 caracteres, cada uno repetido 7 veces.

»⟲

Después de imprimir todas las notas, gire todo en su lugar.

Neil
fuente
Puede contar el y como 1 byte cada uno en lugar de 3.
ericw31415
Esto es genial, no puedo competir con esta solución.
Charlie
6

Ruby , 113 bytes ( 131126108105 con # yb)

-7.upto(7){|i|print i.abs," ♭♯"[i<=>0]," - ",(4..11).map{|j|("FCGDAEB"*3)[k=j*2%7-i]+"♭♯ "[~k/7]}*" ",$/}

Pruébalo en línea!

Ruby , 116 bytes (108 con # yb)

Pruébalo en línea!

Ruby , 126 bytes (118 con # yb)

Pruébalo en línea!

Ruby , 131 bytes con # yb

Pruébalo en línea!

Level River St
fuente
Debe imprimir los caracteres nítidos y planos Unicode porque Ruby los admite.
Jakob
Creo que debería cambiar a la solución de 124 bytes. ¡La métrica aquí es bytes, no caracteres!
Jakob
Puede contar el y como 1 byte cada uno en lugar de 3.
ericw31415
6

Python 3 , 135 bytes

contando ♯ y ♭ como 1 byte cada uno

Gracias a Zacharý por -6 bytes.

for i in range(15):k=' ♯♭'[(i<7)-(i>7)]+' -';print(str(i-7)[-1]+k,*[v+k[a+8>i>a]for a,v in zip([1,3,5,0,2,4,6,1],('CDEFGAB'*8)[i*3:])])

Pruébalo en línea!

ovs
fuente
5

GNU sed , 148144 + 1 = 145 bytes

+1 byte para -rbandera.

s/^/ 7# - C# D# E# F# G# A# B# \n65432101234567/
:
s/((.).(. - )((\S..){3})([^-]+)..\n)([0-7])/\1\2\7\3\6\2 \4\n/
s/ 0#/b0b/
t
s/^.//gm
s/0b/0 /

Pruébalo en línea!

Explicación

Primero, inserte una plantilla de tipo:

 7# - C# D# E# F# G# A# B# 
65432101234567

Tenga en cuenta el espacio inicial y final en la primera línea.

En un bucle, tome el primer número de la última línea y reemplácelo con partes de la penúltima línea de la siguiente manera:

 7# - C# D# E# F# G# A# B# 
│ └┬─┘└───┬───┘└───┬────┘
2  3      4        6
│  │      └────────│──┐
├──│────────────┐  │  │
│  │      ┌─────│──┘  │
│ ┌┴─┐┌───┴────┐│ ┌───┴───┐
 6# - F# G# A# B  C# D# E# 

Como puede ver, el espacio inicial (captura 2) se usa para reemplazar el carácter después de B.

Cuando 0se alcanza el, reemplace el espacio inicial con b. El bucle continúa, pero en lugar de reemplazar #s con espacios, en cada línea subsiguiente se reemplaza un espacio con a b.

Finalmente, haga una pequeña limpieza: elimine el carácter principal de cada línea y reemplácelo 0bcon 0.

Jordán
fuente
4

Befunge, 134 132 130 bytes

<v:,,," - ",g2+!!\`0::,+*86*-1*2`0::p00:<75
@>4*65*+81v>55+,$$\:00g0`!\9p3+7%\1-:8+#^_
 b#"A"%7:\_^#:-1,*84,g2*+1`0g00!!g9%7:\+1,+

Pruébalo en línea!

Explicación

  • Comenzamos con un bucle externo que cuenta de 7 a -7. Llamaremos a esto el número de fila .
  • Para cada fila, comenzamos escribiendo '0'+abs(row)(el número de escala), y luego calculamos (row>0)+(row!=0)para buscar si es natural, nítido o plano en la tabla #b(verá esto al comienzo de la tercera línea de código).
  • Luego calculamos la nota inicial de la escala, n , como 30 + row*4. Esto finalmente será mod 7, así que piense en ello como la secuencia de repetición 2,5,1,4,0,3,6 (es decir, CFBEADG).
  • Nuestro bucle interno, i , luego cuenta regresivamente de 8 a 1, para las ocho notas en la escala, incrementando n en cada iteración.
  • La letra de la nota es sencilla 'A' + n%7. Si es filoso o plano se determina mirando hacia arriba i%7en una mesa. La tabla es inicialmente verdadera, ya que la primera escala es todos los objetos punzantes.
  • Sin embargo, después de que se genera cada fila, actualizamos la tabla alternando un valor. En la primera iteración, cambiaremos el valor en el desplazamiento 5, pero en cada bucle se ajusta el desplazamiento (offset+3)%7.
  • En la primera mitad de la salida, cuando la fila es mayor que cero, estamos alternando estos valores de tabla a falso. En la segunda mitad de la salida, cuando la fila es menor o igual a cero, los estamos volviendo a poner en verdadero.
James Holderness
fuente
1
Solo puedes jugar golf en Befunge.
Zacharý
3

Chicle , 107 bytes

Umbral de chicle

00000000: 4dca a90d 0301 1443 41ee 2a9e f4b1 a5ec  M......CA.*.....
00000010: 8d73 f7e1 fe8b 48a0 e968 aec1 3c87 d7f0  .s....H..h..<...
00000020: 1e3e c377 b80f 8ff9 a3ce c165 74d4 31b8  .>.w.......et.1.
00000030: 8c8a da07 1751 4fdb e022 ea69 1d5c 443d  .....QO..".i.\D=
00000040: 2d83 8ba8 a71b b888 7a5a 828b 524f 6b70  -.......zZ..ROkp
00000050: 51fa 690b 2e4b 47ed c165 e9a8 23b8 2c1d  Q.i..KG..e..#.,.
00000060: 7506 97a5 a3ae e0b2 74d4 0f              u.......t..

Pruébalo en línea!

ovs
fuente
3

JavaScript (ES6), 130 124 bytes

O 128 121 bytes con una nueva línea principal.

f=(y=14,x=8)=>x?f(y,x-1)+' '+'BCDEFGA'[(y*3+x)%7]+'# b'[(x*5%7+y)/7|0]:(y?f(y-1)+`
`:'')+`${y<7?7-y+'#':y>7?y-7+'b':'0 '} -`

O.innerText = f()
<pre id=O style="font-size:11px"></pre>

Arnauld
fuente
3

C,  212   189   186  185 bytes

¡Gracias a @Jonathan Frech por guardar un byte!

#define N n>0?35:98:32);
f(i,n){for(n=8;--n+8;puts(""))for(i=-1,printf("%d%c -",abs(n),n?N++i<8;)printf(" %c%c",(n*4+65+i)%7+65,"\377\277\273\233\231\211\10\0@Ddfv\367\377"[n+7]&1<<i?N}

Pruébalo en línea!

Desenrollado:

#define N n>0 ? 35 : 98 : 32);
f(i, n)
{
    for (n=8; --n+8; puts(""))
        for (i=-1, printf("%d%c -", abs(n), n?N ++i<8;)
            printf(" %c%c",
                (n*4+65+i)%7 + 65,
                "\377\277\273\233\231\211\10\0@Ddfv\367\377"[n+7] & 1<<i ? N
}
Steadybox
fuente
>-puede ser +.
Jonathan Frech
@ JonathanFrech Gracias!
Steadybox
Sugerir en i=~!printflugar de i=-1,printfy en \blugar de\10
ceilingcat
2

Gelatina ,  57 56 55  54 bytes

-1 byte gracias a EriktheOutgolfer (usar 7ŒRpara reemplazar -7r7)

_Ṃị“ b#”
=”B+\Çż
×3⁵+€ịØAḣ7¤ḊḊÇ€Z
7ŒRµṠÑżAW€żÇj€”-UK€Y

Un programa completo que imprime la salida deseada (usando #, b).

Pruébalo en línea!

¿Cómo?

_Ṃị“ b#” - Link 1, getSharpsFlatsOrSpaces: list of integers
 Ṃ       - minimum (of the input list)
_        - subtract (from the input list) -- for our purposes this resets whatever our
         -       1st value is to 0, since our inputs are always monotonically increasing
   “ b#” - literal list of characters = [' ', 'b', '#']
  ị      - index into (1-based and modular)

=”B+\Çż - Link 2, addSharpsFlatsOrSpaces: list of characters  e.g."CFBEADGCFBEADGC"
 ”B     - literal character 'B'
=       - equals? (vectorises)                      [0,0,1,0,0,0,0,0,0,1,0,0,0,0,0]
    \   - cumulative reduce with:
   +    -   addition                                [0,0,1,1,1,1,1,1,1,2,2,2,2,2,2]
     Ç  - call the last link (1) as a monad                       "##       bbbbbb"
      ż - zip (with input) ["#C","#F"," B"," E",...," F","bB","bE","bA","bD","bG","bC"]

×3⁵+€ịØAḣ7¤ḊḊÇ€Z - link 3, getNoteLetters: list of integers          e.g. [-7,-6,...,6,7]
×3               - multiply by three       [-21,-18,-15,-12,-9,-6,-3,0,3,6,9,12,15,18,21]
  ⁵              - literal ten                                                         10
   +€            - add for €ach (in [1,10])   [[-20,...,22],[-19,...,23],...,[-11,...31]]
          ¤      - nilad followed by link(s) as a nilad:
      ØA         -   yield uppercase alphabet                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        ḣ7       -   head to index seven                                        "ABCDEFG"
     ị           - index into ["ADGCFBEADGCFBEA","BEADGCFBEADGCFB","CFBEADGCFBEADGC",...]
           Ḋ     - dequeue    ["BEADGCFBEADGCFB","CFBEADGCFBEADGC","DGCFBEADGCFBEAD",...]
            Ḋ    - dequeue    ["CFBEADGCFBEADGC","DGCFBEADGCFBEAD","EADGCFBEADGCFBE",...]
             Ç€  - call the last link(2) as a monad for €ach
                 -    [[["#C","#F"," B"," E",...," F","bB","bE","bA","bD","bG","bC"],...]
               Z - transpose           [["#C","#D",...,"#C"],["#F",..." B",...,"#F"],...]

7ŒRµṠÑżAW€żÇj€”-UK€Y - Main link: no arguments
7ŒR                  - absolute range of seven     [-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7]
   µ                 - start a new monadic chain (call that r)
    Ṡ                - sign (of r)                 [-1,-1,-1,-1,-1,-1,-1,0,1,1,1,1,1,1,1]
     Ñ               - call the next link (1) as a monad                "####### bbbbbbb"
       A             - absolute value (of r)              [7,6,5,4,3,2,1,0,1,2,3,4,5,6,7]
      ż              - zip                      [[7,'#'],[6,'#'],...,[0,' '],...,[7,'b']]
        W€           - wrap €ach        [[[7,'#']],[[6,'#']],...,[[0,' ']],...,[[7,'b']]]
           Ç         - call the last link (3) as a monad (with r)      see link 3 example
          ż          - zip                     [[[['#',7]],["#C","#D",...,"#C"]],
                                                [[['#',6]],["#F",...," B",..."#F"]], ...]
              ”-     - literal character '-'
            j€       - join for €ach            [[['#',7],'-',"#C","#D",..."#C"],
                                                 [['#',6],'-',"#F",...," B",..."#F"],...]
                U    - upend (reverse each)     [[[7,'#'],'-',"C#","D#",..."C#"],
                                                 [[6,'#'],'-',"F#",...,"B ",..."F#"],...]
                 K€  - join €ach with spaces            [[7+"# - C# D# ... C#"],
                                                         [6+"# - F# ... B  ... F#"], ...]
                   Y - join with newlines
                     - implicit print to STDOUT
Jonathan Allan
fuente
1
Tenía fe en Jelly para este.
Erik the Outgolfer
0

CJAM , 109 106 94 bytes

{_0={_z/}|" b#"=a}:A;15,{X7-_zs\A+" - "+o7,0+{YX+7%65+c"2461357"Y=aiX\-_7,#){;0}&AS++o}fYNo}fX

Pruébalo en línea

Chiel ten Brinke
fuente
0

Java 8, 255 bytes

Contando ♯ y ♭ como 1 byte cada uno.

v->{String r="",t="GABCDEF";for(int i=-8;++i<8;r+="\n"){r+=(i<0?-i+"♯":i>0?i+"♭":"0 ")+" - ";for(String c:((t=t.substring(3)+t.substring(0,3))+t.charAt(0)).split(""))r+=c+("BEADGCF".substring(i<0?7+i:i).contains(c)?i<0?"♯":" ":i>0?"♭":" ")+" ";}return r;}

Explicación:

Pruébalo en línea.

v->{                   // Method with empty unused parameter and String return-type
  String r="",         //  Result-String, starting empty
         t="GABCDEF";  //  Temp-String `t`, starting at "GABCDEF"
  for(int i=-8;++i<8;  //  Loop from -7 to 7 (inclusive); range (-8;8) == [-7;7]
      r+="\n"){        //    After every iteration: append the result with a new-line
    r+=                //   Append the result-String with:
       (i<0?           //    If `i` is negative:
         -i+"♯"        //     Append the absolute value of `i` + a literal "♯"
        :i>0?          //    Else-if `i` is positive:
         i+"♭"         //     Append `i` + a literal "♭"
        :              //    Else (`i` is 0):
         "0 ")         //     Append a literal "0" + space
     +" - ";           //   And then append a literal " - "
  for(String c:((t=t.substring(3)+t.substring(0,3))
                       //  Split String `t` in the middle,
                       //  and swap the two parts (i.e. "GABCDEF" becomes "CDEFGAB")
                +t.charAt(0))
                       //  Then append the first character
                .split(""))
                       //  And loop over each character:
     r+=c+             //   Append the result-String with this character, plus:
          ("BEADGCF".substring(i<0?
                       //    If `i` is negative
            7+i        //     Take the last `-i` characters of "BEAFGCF"
           :           //    Else (`i` is 0 or positive)
            i)         //     Take the last `7-i` characters of "BEAFGCF"
          .contains(c)?//    And if these last characters contain the current character:
            i<0?       //     And `i` is negative:
             "♯"       //      Append a literal "♯"
            :          //     Else (`i` is 0 or positive)
             " "       //      Append a space
          :i>0?        //    Else-if `i` is positive
            "♭"        //     Append a literal "♭"
          :            //    Else:
           " ")        //     Append a space
      +" ";}           //   And then append a space
  return r;}           //  Return the result-String
Kevin Cruijssen
fuente