I deal with sparse graph data structures a lot, as molecular graphs, with a maximum degree of about 5. While graphs can be represented as an adjacency matrix, many of the algorithms become suboptimal in that representation, eg, finding the list of 1-away neighbors becomes an O(n) operation rather than O(1), in the number of nodes.

Now, I'm not saying that these graphs or algorithms can't be represented in APL. But, as an example, consider the problem of how to find strongly connected components in a graph, which is something that is not an unreasonable interview topic for an intermediate developer in my field.

An implementation for Dyalog APL is at https://dfns.dyalog.com/c_scc.htm with commentary at https://dfns.dyalog.com/n_scc.htm . It requires about 30 lines of code, starting:

  scc←{⎕ML←1                                  ⍝ Strongly connected components.
                                              ⍝ (Tarjan)
    loop←{                                  ⍝ for each vertex in graph G
        vert←{⍺ conn⍣(0=X ⍺⊃⍵)⊢⍵}           ⍝ connection of unvisited vertex ⍺
        ⊃vert/(⌽⍳⍴G),⊂⍵                     ⍝   for each vertex in G
    }                                       ⍝ :: T ← ∇ T

    conn←{v←⍺                               ⍝ connection of vertex v
        T0←v trace ⍵                        ⍝ optional tracing
        T1←x1 v push v Lx v Xx T0           ⍝ successor state for x S L and X
        T2←↑{w←⍺                            ⍝ edge v → w
            min_L←{(⍺ w⊃⍵)⌊@(⊂L v)⊢⍵}       ⍝ L[v] ⌊← ⍺[w]
            0=X w⊃⍵:L min_L w conn ⍵        ⍝ w not connected: depth-first trav
            X min_L⍣(w∊S⊃⍵)⊢⍵               ⍝ low-link if w on stack
        }/(⌽v⊃G),⊂T1                        ⍝ for each edge from vertex v
        root←(L v⊃T2)=X v⊃T2                ⍝ is a root vertex?
        v comp⍣root⊢T2                      ⍝ new component if root
    }                                       ⍝ :: T ← v ∇ T
     ...

The pseuocode on the Tarjan's strongly connected components algorithm Wikipedia page (not counting "end if", "end for", etc. lines) is shorter.

One Python implementation is at https://codereview.stackexchange.com/questions/46832/strongl... where you can see it's slightly shorter than the APL version and - I argue - easier to understand.

Now, the APL commentary page points out:

> Nick Nikolov provides this alternative one-liner, which uses the transitive closure of the adjacency matrix (see →Graphs←).

    scc←{(∪⍳⊢)↓∧∘⍉⍨∨.∧⍨⍣≡i∘.∊⍵,¨i←⍳≢⍵}
    ⍝    ·     ·   ·     ·   ·  i←⍳≢⍵   vertex indices
    ⍝    ·     ·   ·     ·   ⍵,¨i   ·   consider each vertex a SCC by itself
    ⍝    ·     ·   ·     i∘.∊   ·   ·   neighbour lists to adjacency matrix
    ⍝    ·     ·   ∨.∧⍨⍣≡   ·   ·   ·   transitive closure: g[x;y] ←→ path x → y
    ⍝    ·     ∧∘⍉⍨ ·   ·   ·   ·   ·   ... and from y to x
    ⍝    (∪⍳⊢)↓ ·   ·   ·   ·   ·   ·   renumbering of component numbers

> The version is very good for small graphs but its space and time requirements grow rapidly as the size increases.

Which, I believe (not knowing more than a trivial amount of APL) is a consequence of using an array data structure rather than something which is a better fit.