J: La autorreferencia en la burbuja de aplicación tipo tácito

Question

Ya que soy principiante en J He decidido resolver una tarea sencilla utilizando este lenguaje, en particular, la implementación del algoritmo de BubbleSort. Yo sé que no es idiomático para resolver este tipo de problema en los lenguajes funcionales, porque está resuelto de forma natural usando conjunto de elementos de transposición en los lenguajes imperativos como C, en lugar de construir la lista modificada en lenguajes declarativos. Sin embargo este es el código que he escrito:

    (((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#)) ^: #

Aquí está la estructura de la declaración:

┌────────────────────────────────────────────────────────────────────────────┬──┬─┐
│┌───────────────────────────────────────────────────────────────┬──┬───────┐│^:│#│
││┌───────────────────┬─┬───────────────────────────────────────┐│^:│┌─┬─┬─┐││  │ │
│││┌──────┬─┬────────┐│,│┌──┬─┬────────────────────────────────┐││  ││1│<│#│││  │ │
││││┌──┬─┐│@│┌─┬─┬──┐││ ││$:│@│┌───────────────────┬─┬────────┐│││  │└─┴─┴─┘││  │ │
│││││<.│/││ ││2│&│{.│││ ││  │ ││┌──────┬─┬────────┐│,│┌─┬─┬──┐││││  │       ││  │ │
││││└──┴─┘│ │└─┴─┴──┘││ ││  │ │││┌──┬─┐│@│┌─┬─┬──┐││ ││2│&│}.│││││  │       ││  │ │
│││└──────┴─┴────────┘│ ││  │ ││││>.│/││ ││2│&│{.│││ │└─┴─┴──┘││││  │       ││  │ │
│││                   │ ││  │ │││└──┴─┘│ │└─┴─┴──┘││ │        ││││  │       ││  │ │
│││                   │ ││  │ ││└──────┴─┴────────┘│ │        ││││  │       ││  │ │
│││                   │ ││  │ │└───────────────────┴─┴────────┘│││  │       ││  │ │
│││                   │ │└──┴─┴────────────────────────────────┘││  │       ││  │ │
││└───────────────────┴─┴───────────────────────────────────────┘│  │       ││  │ │
│└───────────────────────────────────────────────────────────────┴──┴───────┘│  │ │
└────────────────────────────────────────────────────────────────────────────┴──┴─┘

Vamos a aplicar a una matriz:

    (((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#)) ^: # 5 3 8 7 2
2 3 5 7 8

Lo que me confunde es $: refiriéndose a la declaración dentro de los paréntesis más externos. Ayuda dice que:

$: denota el verbo más larga que lo contiene.

El otro libro (~ 300 KiB) dice:

    3+4 
7  
    5*20  
100  

Los símbolos como + y * más y veces en las frases anteriores son llamados verbos y representan funciones. Puedes tener más de un verbo en una frase J, en cuyo caso se construye como una frase en Inglés sencillo por lectura de izquierda a derecha , es decir medios 4+6%2 4 añaden a lo siguiente, a saber 6 dividido por 2.

Vamos a reescribir mi fragmento de código omitiendo más externa ()s:

    ((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#) ^: # 5 3 8 7 2
2 3 5 7 8

reuslts son los mismos. No podía explicarme por qué esto funciona, ¿por qué sólo ((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#) se trata como el verbo más larga para $: pero no toda la ((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#) ^: # expresión y no sólo (<./@(2&{.)), $:@((>./@(2&{.)),2&}.), porque si ((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#) es un verbo, sino que también debe formar otro verbo después de la conjunción con #, yo. mi. uno podría tratar la totalidad de la frase (primer fragmento) como verbo. Probablemente hay algún límite para la longitud verbo limitado por una conjunción.

Mira el siguiente código ( de aquí ):

    factorial =: (* factorial@<:) ^: (1&<)
    factorial 4
24

factorial dentro de expresión se refiere a toda la función, i. mi. (* factorial@<:) ^: (1&<).

Siguiendo este ejemplo he usado un nombre de función en lugar de $::

    bubblesort =: (((<./@(2&{.)), bubblesort@((>./@(2&{.)),2&}.)) ^: (1<#)) ^: #
    bubblesort 5 3 8 7 2
2 3 5 7 8

Me espera bubblesort para referirse a toda la función, pero no parece verdad para mí ya que el resultado es correcto.

También me gustaría ver otras implementaciones si tienes más, aunque sea ligeramente rediseñado.

Gracias.

Answer 1

Según esta referencia (175 KiB) conjunción es:

A parte de la oración que toma dos argumentos y típicamente resulta en una verbo. Por ejemplo, *:^:3 es una función que repite tres cuadratura veces (^: es un conjunción ).

Como ^: cae en la categoría mencionada anteriormente, aplicándolo a los resultados argumentos en el más largo verbo:

((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#)

Debido $: denota el verbo más larga que la contiene, se refiere al código recién escrito anteriormente.

Del mismo modo, el siguiente ^: hace ya un nuevo verbo del ((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#) y #:

(((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#)) ^: #

que a su vez se conoce por $: porque es más largo que el anterior.

Ya que es el comportamiento indeseable, probablemente, la única solución es dividir todo el verbo de manera que $: se refiere a la ((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#) aunque no es un oneliner:

    bubbleiter =: ((<./@(2&{.)), $:@((>./@(2&{.)),2&}.)) ^: (1<#)
    bubblesort =: bubbleiter ^: #
    bubblesort 3 1 2 9 2 9 86 5 9 6 9 6 45
1 2 2 3 5 6 6 9 9 9 9 45 86

Este artículo tiene algunos comentarios en cuanto a $::

Al explicar lo $: (autorreferencia) es y cómo se utiliza resultó ser un punto de partida bastante desafortunado para algunos de los completamente nuevos para el idioma ya que esto es un avanzado característica y es atípica del camino cosas se realiza en J. John mencionó que Roger ha comentado que no incluiría esto si él fueron el diseño de la lengua ahora.

Una vez más, para resumir:

• ^: es un conjunción y hace un nuevo verbo de sus argumentos;
• $: denota el más largo verbo que lo contiene.

Gracias a volar fuera estanford de conjunto de datos 3 1 2 9 2 9 86 5 9 6 9 6 45 en su respuesta.

Answer 2

Estoy buscando en ella. Mientras tanto, están implementando BubbleSort porque necesita BubbleSort específicamente, o porque necesita simplemente una especie (es decir, que podría salir con el uso /:~ lugar)?

EDIT: ¿Usted ha intentado el funcionamiento de su ordenamiento de burbuja en un conjunto de datos como 3 1 2 9 2 9 86 5 9 6 9 6 45? El sistema de colgado cuando lo probé en mi máquina, pero funciona si se reemplaza el final con un # _.

Answer 3

Aquí hay otro enfoque para la implementación de la ordenación de burbuja en J: http://rosettacode.org/wiki/ Sorting_algorithms / Bubble_sort # J