text:
Convert Algebraic notation to Descriptive notation
Mr Short likes to play chess. Mr Short is also a very traditional man. Hence, Mr Short is disturbed by the recent trend of using Algebraic notation in modern chess, and he would rather use Descriptive notation, like his father and his father's father before him.
Note
To simplify this challenge, I chose not to deal with disambiguaties (as in, when two pieces can move to the same square, or can capture the same piece.) Also there is no dealing with en passant, promotion, or Castling.
Algebraic notation for the uninitiated

The board squares are numbered from a1 at the bottom left to h8 as the top right. The letters represent the files (columns) while the numbers represent the ranks (rows). The white King is placed in the beginning of the game at the square e1.
A move consists of the piece that moved + the destination square. For example, a King moving to e2 would be Ke2.
If the piece that had moved is a Pawn, the piece letter is omitted. For example, the starting move Pawn to e4 is written as e4.
If the move is a capture, then the x letter is inserted between the piece and the destination square. For example, a Queen capturing at f7 is annotated as Qxf7.
If the capturing piece is a Pawn, since it moves diagonally, the notation records the file the Pawn originated from. For example, when the Pawn at c4 captures a piece at d5, the move is annotated as cxd5.
Piece symbols are K for King, Q for Queen, B for Bishop, N for Knight, and R for Rook. Pawns have no symbols.
Other annotations include + for check, and # for checkmate. A Pawn moving to f7 and giving check is f7+. Note lack of space.

Descriptive notation for the uninitiated

The files are described by the piece that starts on it. For example, what would be the e file in Algebraic, becomes the King file, or, for short, K. The other files are marked by their side, then the piece. So file h is the King's Rook's file, or KR.
The ranks are numbered from the point of view of the moving player. What would be the fourth rank in Algebraic, is the fourth rank for white, but the fifth rank for black.
It follows that the square e4 is K4 for the white player and K5 for the black player. The square f7 is KB7 for the white player and KB2 for the black player.
A move is annotated by the piece moving, then a dash, then the target square. So a Pawn moving to K4 is P-K4. A Queen moving to KR5 is Q-KR5.
A capture is annotated by the capturing piece, then x, then the captured piece. Therefore a Bishop capturing a Pawn is BxP. Usually you need to mark which Pawn is being captured, but ignore this for sake of simplicity.
Piece symbols are K for King, Q for Queen, B for Bishop, Kt for Knight (note the different symbol), R for Rook, and P for Pawn.
Other annotations include ch for check and mate for checkmate. A Pawn moving to KB7 and giving check is P-KB7 ch. Note the space.

Input
A string of algebraic notation moves, delineated by spaces. There are no move numbers. For example, the Fool's mate goes like this:
f3 e5 g4 Qh4#

Or the game Teed vs Delmar, from the same Wikipedia page:
d4 f5 Bg5 h6 Bf4 g5 Bg3 f4 e3 h5 Bd3 Rh6 Qxh5+ Rxh5 Bg6#

The Immortal game.
e4 e5 f4 exf4 Bc4 Qh4+ Kf1 b5 Bxb5 Nf6 Nf3 Qh6 d3 Nh5 Nh4 Qg5 Nf5 c6 g4 Nf6 Rg1 cxb5 h4 Qg6 h5 Qg5 Qf3 Ng8 Bxf4 Qf6 Nc3 Bc5 Nd5 Qxb2 Bd6 Bxg1 e5 Qxa1+ Ke2 Na6 Nxg7+ Kd8 Qf6+ Nxf6 Be7#

You may assume that input is always a valid game. All moves are in the correct order, and no extraneous data is present. No moves will include disambiguation.
For example, The Evergreen game despite being, obviously, a valid game, is not going to be input due to the 19th move, Rad1.
You may also assume that all input move lists start from the starting position.
Output
A move list, with a similar format, in Descriptive notation.
For example, the Fool's mate:
P-KB3 P-K4 P-KKt4 Q-KR5 mate

Teed vs Delmar:
P-Q4 P-KB4 B-KKt5 P-KR3 B-KB4 P-KKt4 B-KKt3 P-KB5 P-K3 P-KR4 B-Q3 R-KR3 QxP ch RxQ B-KKt6 mate

The Immortal Game:
P-K4 P-K4 P-KB4 PxP B-QB4 Q-KR5 ch K-KB1 P-QKt4 BxP Kt-KB3 Kt-KB3 Q-KR3 P-Q3 Kt-KR4 Kt-KR4 Q-KKt4 Kt-KB5 P-QB3 P-KKt4 Kt-KB4 R-KKt1 PxB P-KR4 Q-KKt3 P-KR5 Q-KKt4 Q-KB3 Kt-KKt1 BxP Q-KB3 Kt-QB3 B-QB4 Kt-Q5 QxP B-Q6 BxR P-K5 QxR ch K-K2 Kt-QR3 KtxP ch K-Q1 Q-KB6 ch KtxQ B-K7 mate

This is not the simplest Descriptive notation possible, since sometimes you don't need to specify which Knight file was moved to (as in, Q-KKt4 could be written as Q-Kt4 since the move Q-QKt4 is impossible.) The move BxP is ambiguous (which pawn: should be BxQKtP), but Mr Short doesn't care about that too much.
You may consider these your test cases.
Note: I wrote these by hand. If you catch any glaring mistakes, please let me know.
Rules and Scoring

Standard rules apply : program with output to stdout, or function. Nothing to stderr. Standard loopholes are forbidden.
Please link to a site where we can test your code.
Code golf: shortest code wins.

In Conclusion
This is my first challenge, so I probably made some noobish errors. Feedback on the question (in the comments, obviously) is appreciated.

If you really want time to work out the kinks of your challenge and get feedback at the same time without any other issues, you can post it as a proposal in the sandbox.

Great first challenge

I thought descriptive notation would be e2-e4 and Ng1-f3 (for e4 and Nf3 respectively from starting position)

What about the reverse, converting Descriptive to Algebraic? It would be of great value with old books!!

I think for the Immortal game, the move is Kt-KB4 instead of Kt-KB3.

Batch, 588 bytes
@echo off
for %%r in (a.R b.Kt c.B d.Q e.K f.B g.Kt h.R)do set %%~nr1=%%~xr&set %%~nr8=%%~xr
for %%r in (a b c d e f g h)do set %%r2=.P&set %%r7=.P
set s=
set a=
:l
set m=%1
set c=
for %%r in (ch.+ mate.#) do if .%m:~-1%==%%~xr set c= %%~nr&set m=%m:~,-1%
set/ab=(a^^%m:~-1%-1)+1,a=7-a
set p=%m:~0,1%
for %%r in (a b c d e f g h)do if %p%==%%r set p=P
for %%r in (QR.a QKt.b QB.c Q.d K.e KB.f KKt.g KR.h)do if .%m:~-2,1%==%%~xr set d=-%%~nr%b%
if %m:~-3,1%==x call set d=x%%%m:~-2%:~1%%
set %m:~-2%=.%p:N=Kt%
set s=%s% %p:N=Kt%%d%%c%
shift
if not "%1"=="" goto l
echo%s%

s is the output string. m is the current move (moves are taken as command-line parameters). a is the current player (0 for White, 7 for Black). b is the row as seen from the point of view of the current player. c is the ch or mate flag. p is the current piece. If there is no piece (i.e. a lowercase letter a-h) then P is substituted. (The N to Kt substitution is done later to save bytes.) The destination column is then looked up in a dictionary. However if the move is actually a capture then the destination becomes an x followed by the piece previously on that square. Either way the destination square is then set to the piece that just moved there. The moves are accumulated until there are no more parameters and then they are printed.
The variables a1...h8 are used to store the last seen piece. The . prefix is there because of the way I initialise the back row; it's hard to loop over two variables at once in Batch unless I'm allowed to begin one with a ..

JavaScript (Node.js), 473 bytes
(n,c=(X=>[...'abcdefgh'].map(a=>[...'12345678'].map(b=>X[a+b]=a<'c'|a>'f'?a<'b'|a>'g'?['R','Kt',...'BQKB','Kt','R'][--b]:'P':''))&&X)({}),g=s=>s?s=='N'?'Kt':s:'P')=>n.split` `.map((e,i)=>(Q=c[S=e.slice(I=e.search(/[a-h](?!x)/),I+2)],((c[S]=g(e.split(/[a-hx]/)[0]))+(e[Z='includes']`x`?'x'+Q:'-'+((S=e[I])>'d'?'K'+['','B','Kt','R']['efgh'.indexOf(S)]:'Q'+['R','Kt','B','']['abcd'.indexOf(S)])+((Y=e[e.search(/\d/)])&&i%2?9-Y:Y))))+(e[Z]`#`?' mate':e[Z]`+`?' ch':'')).join` `

Try it online!
Output is different to the testcase, but it seems like there is an error the OP made. Only 1 mistake, though.
How
Quite simple for such a long program. Creates an object, c, which stores the position of every piece. Handling captures is simple, simply overwrite the square. Inside the map function, we assign Q to the target square's piece before overwriting, then refer to it when a capture is seen. If not a capture, then index into an array to find the correct file (correct me if "file" is not the right term as I'm no expert in chess) and determine the number (9-Y if black turn, Y if white term). Also a few simple invocations of includes and a few extra ternaries add the chs and mates at the end.


text:
Tips for golfing in Jellyfish

Jellyfish is a two-dimensional esoteric programming language inspired by J and written in Python 3. It was inspired by a challenge on PPCG. The name was suggested in PPCG chat as a combination of Jelly, a golfing language inspired by J, and Fish, a two-dimensional esoteric language.

What general tips do you have for golfing in Jellyfish? I'm looking for ideas which can be applied to code-golf problems and which are also at least somewhat specific to Jellyfish.

I don't think we need a tips question for every single language on the planet. Especially if the language is far from finished and has only two users and the question generates tips like "remove unnecessary whitespace" for lack of better ideas, I doubt that this creates content that is actually useful to the community at this point.

I suspect tips threads like this are a sneaky way to advertise the language. We have a place for that.

Golfing tips may partly serve as advertising, but they are a different thing

Use functions before consumed by operators
When calculating the Catalan number, I used this trick in my Jellyfish answer:
p
%C+
 &
>+i

The > function is taking + as argument, while the & takes the same + as functional argument.
As a result, the + that the > gets is unary, while the & makes + binary to be used by C.

Remove unnecessary whitespaces
In my Jellyfish answer to this question, I golfed my program from 41 bytes down to 29 bytes just by finding alternative methods of placing the functions and operators so as to minimize the number of spaces used.
41-byte version:
p
n         +
+  `1
   /+&*
`/*   r&;>i
1

29-byte version:
p
n     +
+`/
`1*
/
+
&*r&;>i

Use the fact that literals cannot take argument to pack things together. For example, in my 29-byte version, I have a 1 above a * which does not affect the performance of *.
The major goal when I was golfing from 41 bytes to 29 bytes is to minimize the whitespaces used on the second line, meaning to minimize the horizontal span of the remaining lines.
Also, in the 41-byte version, I had two occurrences of 1, and in my 29-byte version I combined them.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Golf an InterpretMe interpreter
This is a very simple challenge.
The joke language InterpretMe consists of one command; *, which causes the program to take input of an InterpretMe program and execute it.
An InterpretMe  program will interpret as many InterpretMe programs as there are * in input.

Your goal is to create a program that interprets InterpretMe in as few bytes as possible.

Input
Input will consist of one line ASCII strings, unicode utf-8 strings if you really want, or any character encoding that your language uses, if you want it that much. These strings can either be inputted at the start, or at the start of every run of InterpretMe interpreter. If they are all inputted at the start, the program must output every program line as it begins it.
Output
In this challenge, there will be no output unless the option of one input is chosen, otherwise only termination and non-termination

Test cases consist not of input and output, but input and termination. A newline denotes a new input to be interpreted as InterpretMe.
If using one input at the start, this could be considered what is outputted when these programs are inputted, followed by inactive (do nothing) lines.
1. *   (executes input as an interpret me program, finishes)
2. *   (^same)
3. **  (executes input as an interpret me program, then does this again after the first program is done, finishes)
4. hi  (nothing, first star of previous line finishes)
5. **  (same as the other two star line)
6. hi  (nothing, first star of previous line finishes)
7. hi  (nothing, second star of line 5 finishes, so second star of line 3 finishes, so line 2 finishes, so line one finishes)
[termination] (not outputted)

hi  (does nothing and finishes)
[termination]

*hi  (executes inputted program, finishes)
*yo  (executes inputted program, finishes)
hey  (nothing)
[termination]

Again, this is code-golf, so fewer bytes is better

I don't really understand. Isn't this 0 bytes in pretty much every language?

no, because you have to take input as many times as there are "*"s in a program, then reiterate the same with each input

Can you give an example of a non-termination program?

they always terminate, there is one command "*"

Wait a second? What?

This doesn't seem like a well-defined challenge, since there doesn't seem to be a clear criterion for whether or not a program "actually interpreted" its input.

Well, the criterion is whether it terminates at the right time, or, for a one input program, outputs the right amount of lines

So basically, if (currentline >= cumulativestarcount) terminate?

that's one way to express it, yes

Cool, someone made a challenge with my language :)

05AB1E, 11 bytes
Code:
[¬'*QiIJ}¦Ž

Explanation:
[            # Enter an infinite loop
 ¬           # Get the first character of the input string (leaves the input on the stack)
  '*Qi  }    # If equal to an asterisk...
      I      # Request another line of input and
       J     # Join it to the string that was left on the stack
         ¦   # Remove the first character
          Ž  # If everything is processed, terminate

Uses the CP-1252 encoding. Try it online?.

Python 3, 35 bytes
i=1
while i:i+=input().count('*')-1

sets i to one, adds the amount of '*' -1 to i
I think I can reduce this with ~ trickery I couldn't

Python 3, 39 38 bytes
def f():[f()for c in input()if c=="*"]

Saved 1 byte thanks to @atlasologist

35 bytes in CoffeeScript f=->f()for c in prompt()when c=='*' (I don't want to make another answer since it is a direct copy of yours)

I think you'd save a byte by going with a regular function (def f() instead of the f=lambda).

Ruby, 29 bytes
i=1
i+=gets.count ?*while$.<i

Ruby's magical variable $. keeps track of the number of lines read from stdin. Keep reading input while this number is lower than the count of asterisks (plus the initial 1).

Java only 45 60 101 100 99 bytes
Reverse code-golf :D. I noticed that  I missread the specs (twice), but now it should work. Seems simple enough, perhaps there is a better way of writing this as a lamda expression.
void a(char[]a){for(char b:a)if(b==42)a(new java.util.Scanner(System.in).nextLine().toCharArray());}

Slightly sleazy cheating for only 17 bytes!
void a(char[]a){}

This version will take input via really fast typing

if(b=='*') can be golfed to if(b==42) for -1 byte. And new Java.util.Scanner( should be with a lowercase j. +1 for the reverse code-golfing part. ;)

This answer made my day :D for(int b:a) saves an additional byte, so less than a 100 bytes for doing nothing :D

Thanks! @Frozn (these characters help the comment according to ppcg)

JavaScript, 53 45 44 bytes
f=_=>{for(i in prompt().match(/\*/g))f()}f()

This program is rather annoying to use due to JavaScript's lack of good I/O.
Asks for a program, then asks for another program for every * in the input program.

Mathematica, 38 bytes
f:=StringCases[InputString[],"*":>f];f

APL, 15 bytes
{⍵='*':∇¨⍞⋄⍬}¨⍞

Test:
      {⍵='*':∇¨⍞⋄⍬}¨⍞
*
*
**
hi
**
hi
hi
⍝ termination

Explanation:
              ⍞  read a line from the keyboard
{           }¨   for each character:
 ⍵='*':          if it is *:
         ⍞         read another line from the keyboard
       ∇¨          do the same for each character
          ⋄⍬     otherwise, return empty list (which displays as nothing)

Perl, 33 bytes
for(my$c;$c+=()=<>=~/\*/g;$c--){}

Counts the number of times that * occurs in the input and adds that to the number of times it loops. I feel like there should be a way to do the decrementing in the same step as incrementing but I couldn't figure it out.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Count blocks in a 2D grid
Challenge description
Let's define an W x H grid as a two-dimensional array of length H whose each subarray is of length W. Example: a 2x3 grid (. character used as a blank):
..
..
..

A unit is a single point of a grid. A block is either a single unit or a set of contiguous units (meaning each unit of a block has at least another one next to, above or below it). In the 10x10 grid below there are 4 blocks (units represented by X's):
........X.   ........1.
..X.......   ..2.......
..X.......   ..2.......
..X.......   ..2.......
.......X..   .......3..
.......XX.   .......33.
.......XX.   .......33.
..X.......   ..4.......
..XX..X...   ..44..4...
...XXXX...   ...4444...

Two blocks are distinct if either their positions in the grid or the number of blocks they consist of are different. In the 10x10 grid below there are 5 blocks (they're all 2x2 squares, but their positions are different, therefore they're distinct):
..........   ..........
.XX....XX.   .11....22.
.XX....XX.   .11....22.
..........   ..........
.......XX.   .......33.
.......XX.   .......33.
....XX....   ....44....
....XX....   ....44....
XX........   55........
XX........   55........

Given two integers W and H (W, H > 0), calculate the number of distinct blocks that can be constructed within a W x H grid.
Sample inputs / outputs
(1, 1) -> 1     | only a 1x1 block can be constructed
(1, 2) -> 3     | two 1x1 blocks, and one 1x2 block
(2, 2) -> 13
(3, 3) -> 218
(4, 4) -> 11506

Notes

Remember that this is a code-golf challenge, so make your code as short as possible!
Relevant sequences: A059525, A059020

To clarify: are we supposed to compute the total number of 4-way connected non-empty subsets of the W x H grid?

Yes, I just realized that this whole challenge could be worded much more concisely, but that's the gist.

@shooqie The gist of what?

Of @Zgarb just said, it's an expression...

@TimmyD: it was supposed to be a strict inequality, thanks for pointing that out

Two blocks are distinct if both their positions in the grid and the number of blocks they consist of are different. I think you mean an either/or rather than a both/and here. Else, the sentence doesn't match the example with the 5 2x2 blocks. Also, it would probably be a good thing if you explicitly stated that the blocks for counting aren't all placed on the grid at the same time. That's implied by your (1,2) example, but not explicit. With that being the case, this is very similar to the recent count-the-rectangle challenges.

Python 2, 208 184 169 167 163 bytes
w,h=input()
def f(x):global g;o=g;g&=~2**x;o>g>[x/w==(x+s)/w<f(x+s)or-1<x/w+s<h<f(x+s*w)for s in[-1,1]]
n=i=1<<w*h
while i:g=i=i-1;f(len(bin(g))-3);n-=g>0
print~-n


text:
Compute the Fibonomial Coefficient
Background
The Fibonacci sequence is defined as
$$f(1) = 1 \\ f(2) = 1 \\ f(n) = f(n-1) + f(n-2)$$
The Fibonorial, similar to the factorial, is the product of the first \$n\$ Fibonacci numbers.
$$g(n) = f(1) \times f(2) \times ... \times f(n-1) \times f(n)$$
The Fibonomial coefficient, similar to the binomial coefficient is defined as
$$\begin{align}a(n, 0) & = 1 \\
a(n, k) & = \frac {g(n)} {g(n-k) \times g(k)} \\
& = \frac {f(n) \times f(n-1) \times ... \times f(n-k+1)} {f(1) \times f(2) \times ... \times f(k)}
\end{align}$$
Task
Your goal is to create a function or program to compute the Fibonomial coefficient given two non-negative integers \$n\$ and \$k\$ with \$l \le n\$.
Test Cases
a(0, 0) = 1
a(1, 1) = 1
a(2, 0) = 1
a(3, 2) = 2
a(8, 3) = 1092
a(11, 5) = 1514513
a(22, 7) = 7158243695757340957617
a(25, 3) = 49845401197200
a(50, 2) = 97905340104793732225
a(100, 1) = 354224848179261915075

Rules

This is code-golf so the shortest code wins.
Builtins are allowed.

Related

A000045 - Challenge - Fibonacci Sequence
A003266 - Challenge - Fibonorial
A010048 - Fibonomial coefficient

If needed, here is a webpage that lists the first 1335 values in the Fibonomial Coefficient sequence.

Is the a(50, 2) test case missing a leading 9?

@SirBidenXVII Oh yes, you're right I missed a digit.

Jelly, 16 bytes
0+⁸Ð¡1ḊP
;_/Ç€:/

Try it online!
Credits to Dennis for the Fibonacci-orial helper link.
;_/Ç€:/     Main chain,  argument: [n,r]
 _/         Find n-r
;           Attach it to original: [n,r,n-r]
   Ç€       Apply helper link to each element, yielding [g(n),g(r),g(n-r)]
     :/     Reduce by integer division, yielding g(n)//g(r)//g(n-r)

0+⁸Ð¡1ḊP    Helper link, argument: n
0+⁸Ð¡1ḊP    Somehow return the n-th Fibonacci-orial.

Python 67 bytes
f=lambda n,a=1,b=1:n<1or a*f(n-1,b,a+b)
lambda n,k:f(n)/f(k)/f(n-k)

Call using a(n,k). Uses @Dennis fibonorial answer (is that allowed?), and a straightforward implementation of the question otherwise.

All user content is licensed under CC-BY-SA, so as long as you provide attribution, you can reuse code from other answers. You can shorten your second lambda to lambda n,k:f(n)/f(k)/f(n-k); naming it is not required.

Haskell, 46 bytes
l=0:scanl(+)1l;a%0=1;a%b=(a-1)%(b-1)*l!!a/l!!b

Outputs floats. Generates the infinite Fibonacci list. Then, does the binomial recusion, multiplying and dividing by elements from the Fibonacci list.

Haskell, 77 57 55 52 50 bytes
The first line is originally coming from the Fibonacci function or sequence challenge and was written by @Anon.
The second line was added in the Fibonacci-orial challenge by @ChristianSievers.
Now I added the third line. How much further will those challenges go?=)
f=1:scanl(+)1f
g=(scanl(*)1f!!)
n#k=g n/g(n-k)/g k

Thanks for 5 bytes @xnor!

Can you do / rather than div?

Hm yes, but that would end up in floating point numbers.

Oh, that is actually not disallowed, thanks=)

You can presumably divide twice to avoid parens.

Yes floats are allowed and there is no time limit so the recursive Fibonacci definition you used earlier was also valid.

It looks tempting to extract out the scanl(?)1f pattern in the first two lines, but q o=scanl o 1f;f=1:q(+);g=(q(*)!!);n#k=g n/g(n-k)/g k is 3 chars longer.

Now that we have this, the next thing could be the fibonomial transform  ;-)

Or maybe some kind of Fibonomial integration >.>

C, 206 bytes:
#include <inttypes.h>
uint64_t F(x){return x<1 ? 0:x==1 ? 1:F(x-1)+F(x-2);}uint64_t G(H,B){uint64_t P=1;for(B=3;B<=H;B++)P*=F(B);return P;}main(U,Y){scanf("%d %d",&U,&Y);printf("%llu\n",G(U)/(G(U-Y)*G(Y)));}

Upon execution, asks for 2 space separated integers as input. The #include preprocessor is required, as without it, uint_64 is not a valid type, and the only other way to make this work for fairly big outputs is using unsigned long long return types for both the F (Fibonacci) and G (Fibonorial) functions, which is much longer than just including the <inttypes.h> and using 3 uint64_t type declarations. However, even with that, it stops working correctly at input values 14 1 (confirmed by using this, which lists the first 1325 values in the Fibonomial Coefficient sequence), most likely because the Fibonacci and/or Fibnorial representation of numbers 15 and above overflow the 64-bit integer type used.
C It Online! (Ideone)

It's probably since the Fibonorial of 15 overflows uint_64

Cheddar, 75 64 bytes
a->b->(g->g((a-b+1)|>a)/g(1|>b))(n->n.map(Math.fib).reduce((*)))

Usage
cheddar> var f = a->b->(g->g((a-b+1)|>a)/g(1|>b))(n->n.map(Math.fib).reduce((*)))
cheddar> f(11)(5)
1514513

MATL, 25 23 bytes
1ti2-:"yy+]vtPi:)w5M)/p

Try it online!
Explanation
1t      % Push 1 twice
i2-:    % Take input n. Generate vector [1 2 ... n-2]
"       % Repeat n-2 times
  yy    %   Push the top two elements again
  +     %   Add them
]       % End
v       % Concatenate into column vector of first n Fibonacci numbers
tP      % Duplicate and reverse
i:      % Take input k. Generate vector [1 2 ... k]
)       % Apply index to get last k Fibonacci numbers
w       % Swap to move vector of first n Fibonacci numbers to top
5M      % Push [1 2 ... k] again
)       % Apply index to get first k Fibonacci numbers
/       % Divide element-wise
p       % Product of vector. Implicitly display

R, 120 bytes
Some more golfing is probably be possible, so comments are of course welcomed !
I used my answer of the Fibonacci-orial question in the begining of the code :
A=function(n,k){p=(1+sqrt(5))/2;f=function(N){x=1;for(n in 1:N){x=prod(x,(p^n-(-1/p)^n)/sqrt(5))};x};f(n)/(f(k)*f(n-k))}

Ungolfed :
A=function(n,k){
p=(1+sqrt(5))/2
    f=function(N){
        x=1
        for(n in 1:N){
           x=prod(x,(p^n-(-1/p)^n)/sqrt(5))
                     }
        x
        }

f(n)/(f(k)*f(n-k))
}

Java: 304 260 257
I saved some bytes by compacting the memoization function a bit and removing f(n) entirely, replacing it with direct array access.
BigInteger[]c;BigInteger a(int n,int k){m(n);return g(n).divide(g(n-k)).divide(g(k));}BigInteger g(int n){return n<3?BigInteger.ONE:g(n-1).multiply(c[n-1]);}void m(int n){c=new BigInteger[n];for(int i=0;i<n;++i)c[i]=(i<2)?BigInteger.ONE:c[i-2].add(c[i-1]);}

Unfortunately, BigInteger is required due to overflows and I had to add memoization. Even on a generation 6 i7, it was taking way too long to run with large inputs.
Ungolfed, with boilerplate class and main code:
import java.math.BigInteger;

public class ComputeTheFibonomialCoefficient {

  public static void main(final String[] args) {
    // @formatter:off
    String[][] testData = new String[][] {
      { "0", "0", "1" },
      { "1", "1", "1" },
      { "2", "0", "1" },
      { "3", "2", "2" },
      { "8", "3", "1092" },
      { "11", "5", "1514513" },
      { "22", "7", "7158243695757340957617" },
      { "25", "3", "49845401197200" },
      { "50", "2", "97905340104793732225" },
      { "100", "1", "354224848179261915075" }
    };
    // @formatter:on

    for (String[] data : testData) {
      System.out.println("a(" + data[0] + ", " + data[1] + ")");
      System.out.println("  Expected -> " + data[2]);
      System.out.print("    Actual -> ");
      System.out.println(new ComputeTheFibonomialCoefficient().a(
          Integer.parseInt(data[0]), Integer.parseInt(data[1])));
      System.out.println();
    }
  }

  // Begin golf

  BigInteger[] c;

  BigInteger a(int n, int k) {
    m(n);
    return g(n).divide(g(n - k)).divide(g(k));
  }

  BigInteger g(int n) {
    return n < 3 ? BigInteger.ONE : g(n - 1).multiply(c[n - 1]);
  }

  void m(int n) {
    c = new BigInteger[n];
    for (int i = 0; i < n; ++i)
      c[i] = (i < 2) ? BigInteger.ONE : c[i - 2].add(c[i - 1]);
  }
  // End golf
}

Program output:
a(0, 0)
  Expected -> 1
    Actual -> 1

a(1, 1)
  Expected -> 1
    Actual -> 1

a(2, 0)
  Expected -> 1
    Actual -> 1

a(3, 2)
  Expected -> 2
    Actual -> 2

a(8, 3)
  Expected -> 1092
    Actual -> 1092

a(11, 5)
  Expected -> 1514513
    Actual -> 1514513

a(22, 7)
  Expected -> 7158243695757340957617
    Actual -> 7158243695757340957617

a(25, 3)
  Expected -> 49845401197200
    Actual -> 49845401197200

a(50, 2)
  Expected -> 97905340104793732225
    Actual -> 97905340104793732225

a(100, 1)
  Expected -> 354224848179261915075
    Actual -> 354224848179261915075

JavaScript (ES6), 70 bytes
a=n=>n<2?1:a(--n)+a(--n);b=n=>n?a(--n)*b(n):1;c=n=>k=>b(n)/b(n-k)/b(k)

Call using c(n)(k), pretty straightforward.

Ruby, 72 bytes
Special thanks to @st0le for the really short Fibonacci generation code.
->n,k{f=[a=b=1,1]+(1..n).map{b=a+a=b}
r=->i{f[i,k].inject:*}
k>0?r[n-k]/r[0]:1}

dc, 67 bytes
?skdsn[si1d[sadlarla+zli>b*]sbzli>b*]dsgxsplnlk-lgxsqlklgxlprlqr*/f

Input is taken as space-delimited decimal constants on a single line.
This uses my answer to the /Fibon(acci-)?orial/ question, which multiplies all numbers on the stack in the last step, requiring the other numbers to be stored elsewhere while the other Fibonorials are calculated.
?       # Take input from stdin
skdsn   # Store second number in register `k'; store a copy of first number in register `n'
[si1d[sadlarla+zli>b*]sbzli>b*] # Compute Fibonorial of top-of-stack, multiplying
                                #   until stack depth is 1
dsgx    # Store a copy of this function as g and execute it: g(n)
sp      # Store g(n) in register `p'
lnlk-   # Compute n-k
lgx     # Compute g(n-k)
sq      # Store g(n-k) in register `q'
lk lgx  # Compute g(k)
        # Top ---Down--->
lp      #  g(n)    g(k)
r       #  g(k)    g(n)
lq      #  g(n-k)  g(k)    g(n)
r       #  g(k)    g(n-k)  g(n)
*       # (g(k)g(n-k))     g(n)
/       #  g(n)/(g(k)g(n-k))
f       # Dump stack to stdout

Julia, 53 bytes
!x=[([1 1;1 0]^n)[2]for n=1:x]|>prod;n\k=!n/!(n-k)/!k

Credits to @Lynn for his Fibonorial answer.

Axiom 108 bytes
b(n,k)==(n<=k or k<1=>1;reduce(*,[fibonacci(i) for i in (n-k+1)..n])/reduce(*,[fibonacci(i) for i in 1..k]))

some test
(34) -> b(0,0),b(1,1),b(2,0),b(3,2),b(8,3),b(11,5),b(22,7)
   Compiling function b with type (NonNegativeInteger,
      NonNegativeInteger) -> Fraction Integer
   Compiling function b with type (PositiveInteger,PositiveInteger) ->
      Fraction Integer
   Compiling function b with type (PositiveInteger,NonNegativeInteger)
       -> Fraction Integer

   (34)  [1,1,1,2,1092,1514513,7158243695757340957617]
                                                 Type: Tuple Fraction Integer
(35) -> b(25,3),b(50,2),b(100,1)

   (35)  [49845401197200,97905340104793732225,354224848179261915075]

                                                     Type: Tuple Fraction Integer

Mathematica, 30 bytes
(f=Fibonorial)@#/f[#-#2]/f@#2&

Jelly, 10 bytes
;ạ/RÆḞP€÷/

Try it online!
How it works
;ạ/RÆḞP€÷/ - Main link. Takes [n, r] on the left
 ạ/        - Calculate |n-r|
;          - Yield [n, r, |n-r|]
   R       - Convert each to a range
    ÆḞ     - For each integer i, yield the i'th Fibonacci number
      P€   - Get the product of each array, yielding [g(n), g(r), g(n-r)]
        ÷/ - Yield g(n) ÷ g(r) ÷ g(n-r) = g(n) ÷ (g(r) × g(n-r))

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
A Fractional Year
My PPCG holiday is over :D
Intro
Fractional time is the year + (the value (minute of year) / number of minutes in the year).
Example calculation
You should assume that February always has 28 days and the year is always 365 days long.
Let's say we want to convert the time: 17:34 3rd March 2013 to fractional time. Firstly, you find how many minutes were in 2013: 525600 minutes. Let's call this x.
Next, you want to find out how many minutes there have been since the start of 2013. A few quick calculations will tell you that the answer is 88894 minutes:
There have been 61 days since the start of the year, which times 1440 (number of minutes in a day) equals 87840 minutes. In 17 hours are 1020 minutes (17*60). Now, we can add 87840, 1020 and 34 minutes to equal 88894 minutes.
Let's call this y.
Finally, you divide y by x and add the year, resulting in 2013.16912 (to 5 decimal places).
Input
The date and time will be given as a single string. The string will be in the following format:
YYYY-MM-DD hh:mm

The time will always be in 24 hour format and the year will always be in the range 1900-2050 inclusive.
Examples
Input:  2016-08-06 23:48
Output: 2016.59723

Input:  2013-03-03 17:34
Output: 2013.16912

Input:  1914-11-11 11:11
Output: 1914.86155

If you are going for the bounty, either ping me in the comments or in The Nineteenth Byte.
Challenge
Calculate the given date and time as a fractional year.
Give all output to five decimal places (you may round in anyway you wish: flooring, ceiling, or true rounding). Shortest code wins.
Bounty
I am offering a 100 rep bounty for the shortest program which also accepts the date in fractional year format and returns the time in YYYY-MM-DD hh:mm format. In essence, your program (or function) has to act in the following way:
f('1914-11-11 11:11') => 1914.86155
f('1914.86155')       => 1914-11-11 11:11

t-clausen.dk - 154 bytes
Neil - 183 bytes

Leaderboard

var QUESTION_ID=88924,OVERRIDE_USER=30525;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Perhaps taking the date and time as an input would allow for test cases and easier checking?

I'm a bit confused as to whether this takes into account leap years given For this, assume February has 28 days and the year is 365 days long., but also ... using the Gregorian calendar.

@DestructibleWatermelon No, it does not take into account leap years

can we give more than five decimal places?

@DestructibleWatermelon No

Is it okay if the output is rounded off to the nearest hundredth-thousandth, i.e. input 2016-08-06 23:48 returns 2016.59724 instead of 2016.59723?

@R.Kap Yes, that's fine

@βετѧΛєҫαγ Is it ok to handle leap years with February having 29 days? (@t-clausen.dk's comment for reference)

@pajonk No, leap years should not be handled

TSQL, 63 bytes
This is a shorter version than my original answer, because my initial answer included calculation for leap year.
DECLARE @ VARCHAR(16) ='1914-11-11 11:11'

PRINT LEFT(YEAR(@)+DATEDIFF(mi,0,STUFF(@,1,4,1900))/525600.,10)

Fiddle
The following sql can handle both input types
TSQL, 154 bytes
DECLARE @ VARCHAR(16) ='1914-11-11 11:11'--can be replaced with '1914.86155'

PRINT IIF(isdate(@)=1,LEFT(YEAR(@)+DATEDIFF(mi,0,STUFF(@,1,4,1900))/525600.,10),LEFT(@,4)+RIGHT(CONVERT(CHAR(16),DATEADD(mi,1*RIGHT(@,5)*5.256,0),20),12))

Combined Fiddle 1
Combined Fiddle 2

JavaScript (ES6), 84 bytes

f=
s=>(Date.parse(1970+s.slice(4).replace(/ /,'T')+'Z')/31536e6+parseInt(s)).toFixed(5)
;
<input placeholder=Input oninput=o.value=f(this.value)><input placeholder=Output id=o>

Assuming no leap years or DST are required, I replace the year with 1970 which makes Date.parse directly return the time offset in milliseconds, of which there were 31536000000 in 1970 (or indeed any other non-leap year). All I need do then is to add back the year and round to 5 decimal places. Edit: Bidirectional conversion in 183 178 bytes:

f=
s=>/:/.test(s,m=31536e6)?(Date.parse(1970+s.slice(4).replace(/ /,'T')+'Z')/m+parseInt(s)).toFixed(5):s.slice(0,4)+new Date(s.slice(4)*m+3e4).toJSON().slice(4,16).replace(/T/,' ')
;
<input placeholder=Input oninput=o.value=f(this.value)><input placeholder=Output id=o>

Assumes strings containing a : are time format, handled as above, otherwise strips off the year, converts to milliseconds, adds half a minute for rounding purposes, converts to a date in 1970, extracts the month, day, hour and minute, and prefixes the original year.

@βετѧΛєҫαγ Yes, s is the argument to the function.

Doesn't this give invalid output, because the challenge explicitly asks for Feb to only have 28 days, and 365 days per year total?

@TimmyD sometimes february has 29 days. Let's assume doesn't mean it is dissallowed to handle leap years correctly

@t-clausen.dk Sorry, I meant that leap years should not be handled

@βετѧΛєҫαγ Now using neither leap years nor DST, and also has a reversible version. Is that satisfactory?

@Neil Yes, this is perfect

Matlab, 132 115 bytes
 d=input('');m=cumsum([-1 '# #"#"##"#"'-4]);year(d)+fix((((m(month(d))+day(d))*24+hour(d))*60+minute(d))/5.256)/10^5

Rounds towards 0.
Hmmm... That's quite long.
That's using some builtins, but not the really helpful ones - because of leap years.
Parsing the string directly gives 2 more byte solution:
d=sscanf(input(''),'%d%[- :]');m=cumsum([-1 '# #"#"##"#"'-4]);d(1)+fix((((m(d(3))+d(5))*24+d(7))*60+d(9))/5.256)/10^5

Newer Matlab versions probably have some better split function, but I'm running on 2012a.
Some bytes saved thanks to @Luis Mendo

You can define the array with [-1 '# #"#"##"#"'-4] to save a few bytes. Are year etc standard functions? If you are using a toolbox you should indicate it in the title, e.g. "Matlab with Financial Toolbox"

@LuisMendo I'm not familiar with the #-notation and never even encountered it. Where can I read more about it (quick Google search didn't help)? I think the year etc. are standard functions, but I don't know if they behave the same outside the toolbox (docs).

It's not special notation. It's just a string with characters that have the appropriate ASCII codes to produce the required numbers. As for the functions, I didn't know, thanks for clarifying. Matlab 15b doesn't seem to have them

Oh, that's clever.

PowerShell v3+, 131 bytes
$t=date $args[0];$a=1440*!!(date "2-29-$($t.year)");"{0:F5}"-f((($t.DayOfYear-1)*1440+$t.TimeOfDay.TotalMinutes-$a)/525600+$t.Year)

Takes input $args[0] and converts it with Get-Date to store into .NET [datetime] format, stores into $t. Calculates whether February 29th exists, and sets $a so we subtract out that date's worth of minutes (if present).
Then we use the -format operator with a fixed-string specification of 5 decimal digits to run through the calculation. Uses built-ins to calculate the .DayOfYear and the .TotalMinutes of the given input, subtract $a if it's a leap year, divide by 525600 minutes total, and add on the input .Year.
Will complain (verbosely) to STDERR if February 29th doesn't exist (see examples below), but since STDERR is ignored by default, we don't worry about that. Also, note that PowerShell does banker's rounding by default.
Examples
PS C:\Tools\Scripts\golfing> .\fractional-year.ps1 '2016-08-06 23:48'
2016.59724

PS C:\Tools\Scripts\golfing> .\fractional-year.ps1 '2013-03-03 17:34'
Get-Date : Cannot bind parameter 'Date'. Cannot convert value "2-29-2013" to type "System.DateTime". Error: "String was not recognized as a valid DateTime."
At C:\Tools\Scripts\golfing\fractional-year.ps1:7 char:36
+   $t=date $args[0];$a=1440*!!(date "2-29-$($t.year)");"{0:F5}"-f((($t.DayOfYear- ...
+                                    ~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidArgument: (:) [Get-Date], ParameterBindingException
    + FullyQualifiedErrorId : CannotConvertArgumentNoMessage,Microsoft.PowerShell.Commands.GetDateCommand

2013.16913

PS C:\Tools\Scripts\golfing> .\fractional-year.ps1 '1914-11-11 11:11'
Get-Date : Cannot bind parameter 'Date'. Cannot convert value "2-29-1914" to type "System.DateTime". Error: "String was not recognized as a valid DateTime."
At C:\Tools\Scripts\golfing\fractional-year.ps1:7 char:36
+   $t=date $args[0];$a=1440*!!(date "2-29-$($t.year)");"{0:F5}"-f((($t.DayOfYear- ...
+                                    ~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidArgument: (:) [Get-Date], ParameterBindingException
    + FullyQualifiedErrorId : CannotConvertArgumentNoMessage,Microsoft.PowerShell.Commands.GetDateCommand

1914.86155

Alternately, with leap years, 119 bytes
"{0:F5}"-f((($t=date $args[0]).DayOfYear-1+$t.TimeOfDay.TotalMinutes/1440)/(date "12-31-$($t.year)").DayOfYear+$t.Year)

If we follow calendar settings, we can shave off a dozen bytes because we won't need to account for $a in the original code above. This allows us to move $t into the expression itself, and we'll explicitly calculate the .DayOfYear for December 31st. Otherwise, follows the same methodology.

Python 3, 163 173 bytes
more bytes because of output format
doesn't use any date builtins, like the java answer.
def s(x):z=x[5:10].split("-");v=x[10:].split(":");return int(x[:4])+(sum(([-1,31,28]+[31,30,31,30,31]*2)[:int(z[0])],int(z[1]))*1440+int(v[0])*60+int(v[1]))/525600

slightly more readable
def s(x):
    date=x[5:10].split("-");time=x[10:].split(":")
    return int(x[:4])+(sum(([-1,31,28]+[31,30,31,30,31]*2)[:int(date[0])],int(date[1]))*1440+int(time[0])*60+int(time[1]))/525600

Perl 6,  107 105  102 bytes
{$/=.comb(/\d+/);($0+(sum(|flat(-1,31,28,(31,30,31,30,31)xx 2)[^$1],$2)*1440+$3*60+$4)/525600).fmt: '%.5f'}
{$/=.comb(/\d+/);fmt $0+(sum(|flat(-1,31,28,(31,30,31,30,31)xx 2)[^$1],$2)*1440+$3*60+$4)/525600: '%.5f'}

{$/=.comb(/\d+/);fmt $0+(flat($2-1,31,28,(31,30,31,30,31)xx 2)[^$1].sum*1440+$3*60+$4)/525600: '%.5f'}
{$/=.comb(/\d+/);round $0+(flat($2-1,31,28,(31,30,31,30,31)xx 2)[^$1].sum*1440+$3*60+$4)/525600,.1⁵}

Explanation:
{
  $/ = .comb(/\d+/); # grab a list of only the digits
  # ｢$0｣ is short for ｢$/[0]｣

  fmt

    $0 # year
    +
    (
      flat(
        $2 -1,                     #    days
        31,28,(31,30,31,30,31)xx 2 # -+ months
      )[^$1].sum * 1440            # /
      + $3 * 60                    #    hours
      + $4                         #    minutes
    )
    /
    525600

  : '%.5f' # the ｢:｣ is used here as ｢fmt｣ is a method not a subroutine
}

Test:
#! /usr/bin/env perl6
use v6.c;
use Test;

# returns Str
my &fractional-year-a = {$/=.comb(/\d+/);fmt $0+(sum(flat($2-1,31,28,(31,30,31,30,31)xx 2)[^$1])*1440+$3*60+$4)/525600: '%.5f'}
# returns Rat
my &fractional-year-b = {$/=.comb(/\d+/);round $0+(sum(flat($2-1,31,28,(31,30,31,30,31)xx 2)[^$1])*1440+$3*60+$4)/525600,.1⁵}

my @tests = (
  '2016-08-06 23:48' => 2016.59723,
  '2013-03-03 17:34' => 2013.16912,
  '1914-11-11 11:11' => 1914.86155,
);

plan +@tests * 2;

for @tests -> $_ ( :key($input), :value($expected) ) {
  is-approx +fractional-year-a($input), +$expected, 1e-5, "a $input => $expected";
  is-approx +fractional-year-b($input), +$expected, 1e-5, "b $input => $expected";
}

1..6
ok 1 - a 2016-08-06 23:48 => 2016.59723
ok 2 - b 2016-08-06 23:48 => 2016.59723
ok 3 - a 2013-03-03 17:34 => 2013.16912
ok 4 - b 2013-03-03 17:34 => 2013.16912
ok 5 - a 1914-11-11 11:11 => 1914.86155
ok 6 - b 1914-11-11 11:11 => 1914.86155

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
A square of text
The Challenge
Given a string, output the text in the shape of a square.
You can assume that the text will always fit in a square, and that it will never be an empty string.
You can also assume it will never have newlines.
Example
Input:
Hi, world

Output:
Hi,
 wo
rld

Test Cases
Input:
Hi, world! Hello

Output:
Hi,
worl
d! H
ello

Input:
Lorem ipsum dolor sit amt

Output:
Lorem
 ipsu
m dol
or si
t amt

Input:
H

Output:
H

Rules

This is code-golf, so shortest answer in bytes wins! Tiebreaker is most upvoted answer.
Standard loopholes are forbidden.

Can we assume that the input will never have new lines?

@MayorMonty yep.

Can we output array of strings instead?

@LeakyNun no 15 chars

May we print with a trailing newline?

Can it be a function or only full programs are allowed?

Also, can we assume ASCII or UTF-8 support is required?

05AB1E, 5 bytes
Dgtô«

Try it online!
D    duplicate a (implicit input)
g    length of a
t    square root of a
ô    push a split in pieces of b
«    join by newlines (implicit output)

Great answer. But how does it work? Could you please [edit] to add an explanation?

@grooveplex done.

Very impressive!

It's weird to see old 05AB1E answers where » is newlines now.

Vim, 59, 57, 48 bytes/keystrokes
$:let @q=float2nr(sqrt(col('.')))."|li<C-v><cr><C-v><esc>@q"<cr>@q

Since V is backwards compatible, you can Try it online!
I randomly received an upvote on this answer, so I looked over it again. My vim-golfing skills have greatly increased over the last 7 months, so I saw that this answer was very poorly golfed. This one is much better.

Brainfuck, 116 112 bytes
>>>>,[[<]<<+>>>[>],]<[<]<+<[>>+<[-<-<+>>]<<++[->>+<<]>]>[-]>>[<[->.[-]<[->+<]<+[->+<]>>]++++++++++.[-]<[->+<]>>]

Try it online!
Safe in flavours of BF that does not mask the cells with 256, does not support null bytes.
Remove the initial right arrows if the flavour supports negative memory for 4 bytes saved.
Explanation
The program is divided into 3 stages:
Stage 1: >>>>,[[<]<<+>>>[>],]<[<]
Stage 2: <+<[>>+<[-<-<+>>]<<++[->>+<<]>]>[-]>>
Stage 3: [<[->.[-]<[->+<]<+[->+<]>>]++++++++++.[-]<[->+<]>>]

Stage 1
In this stage, we put all the characters onto the tape, while keeping count of the number of characters.
This is the tape for the input abcdefghi after this tape:
000 009 000 000 095 096 097 098 099 100 101 102 103
             ^

The 009 is the count.
For each character, we move the the first zero on the left [<] and then add one to the count <<+>>>, and then move to the rightmost zero [>] to get ready for the next character.
Stage 2
This stage does the square root of the length stored in the second cell.
It keeps subtracting by 1, 3, 5, 7, ... until the number reaches zero, while keeping check of the number of iterations.
It works because square numbers can be expressed as 1 + 3 + 5 + ....
Stage 3
Denote the square root of the length found above as n.
This stage outputs n characters at a time, and then output a newline, until the tape is cleared.

+1 didnt read looks amazing though

Python 2, 55 bytes
s=input()
n=int(len(s)**.5)
while s:print s[:n];s=s[n:]

Interesting is a=lambda s,a=0:s[a:(int(c:=a+len(s)**0.5))]+"\n"+(a(s[c:],c)if s else"") implementating as a recursive function but unfortunately it errors and is also longer.

MATL, 6 bytes
tnX^e!

Try it online!
Explanation
t     % Take input implicitly. Push another copy
n     % Get number of elements of the copy
X^    % Take square root
e     % Reshape the input into that number of rows, in column-major order
      % (which means: down, then across)
!     % Transpose so that text reads horizontally. Implicitly display

square "toor"? :P

@daHugLenny :-D. Corrected

@daHugLenny That's the inverse of the square root. ;-)

Jelly, 8 7 bytes
sLÆ½$j⁷

Saved a byte thanks to @Dennis.
Try it online.
Explanation
sLÆ½$j⁷  Input: string S
    $    Monadic chain
 L         Get the length of S
  Æ½       Take the integer square root of it, call it n
s        Split S into chunks of size n
     j⁷  Join using newline

œs and s do the same thing here.

Why does ½ not work instead of Æ½?

@LuisMendo Because it returns a float. I'll patch s and œs so they cast to int.

@Dennis long-awaited patch still waiting...

JavaScript (ES7), 49 bytes
s=>s.match(eval(`/.{${s.length**.5}}/g`)).join`
`

44 bytes in Firefox Nightly 43-46 only (** was introduced some time between Firefox Nightly 42 and 43 and g as a separate parameter was removed some time between Firefox Nightly 46 and 47):
s=>s.match(`.{${s.length**.5}}`,`g`).join`
`

In the first version why do you need the + in s.length*+.5

I've never seen the *+ syntax before. Could someone please explain it?

He probably means **.

@MayorMonty Yeah it was a typo sorry.

@Downgoat It was a typo sorry.

Interestingly enough, a*+b is parsed by JavaScript as a * (Number(b)), because of JavaScript's right to left operator parsing

+1 for having your score be n².  Mine is too :)

@DigitalTrauma That doesn't seem to be that unusual... now what would be neat is an answer that was folded into a square of text!

Oh I'm loving the ** operator... this is a newly established ES7 feature?

@WallyWest https://tc39.github.io/ecma262/2016/#sec-exp-operator

J, 9 bytes
$~,~@%:@#

This is a monadic hook over the input string:
$~ ,~@%:@#

The right tine is a series of compositions:
,~ @ %: @ #

The left is a shaping verb, switched such that it works in the hook format.
Here are some intermediate results:
   # 'hiya'
4
   %:@# 'hiya'
2
   ,~@%:@# 'hiya'
2 2

In words:
   size =: #
   sqrt =: %:
   dup =: ,~
   on =: @
   shape =: $~
   block =: shape dup on sqrt on size
   block 'Hello, World! :)'
Hell
o, W
orld
! :)

I like the fact that $~,~@ resembles some sort of emoticon but @ seems weird for an ear but & fits better, or $~,~&

And I do suppose they are functionally equivalent. Well, mostly. One lets you hear better than the other ;)

+1 for having your score be n².  Mine is too :)

@DigitalTrauma fun! +1 likewise!

$~2#%:@# is 8. The left part of a fork can be a constant.

Perl, 23 + 4 (-pF flags) = 27 bytes
-2 bytes thanks to @DomHastings
-1 bytes thanks to @DomHastings
$==sqrt@F;s/.{$=}/$&
/g

Try it online!
Expanations : computes the square root (lets call it S for the explanation) of the size of the input (it will be always be an integer) (@F is used in scalar context, thus returning its size), then add a newline after each bloc of S characters.

Nice use of $@, ;) You can save a byte using y///c instead of length and I think you can use a literal new line as well. I was looking as trying to do something with setting $, and matching, but I think this is much shorter!

@DomHastings Yea, I thought you'd like the $@! Thanks for the y///c, I tend to forget that it exists.

@DomHastings managed to save 1 byte by using $= instead of $@, which allows to not use -l flag.

Good going! Good to use the magic variables for genuine reasons too!

Hey, hope you're doing alright! This got bumped to homepage and I noticed another optimisation for -1: 23 bytes code + 4 for -pF

@DomHastings Hey! I'm fine, thanks, just a little bit busy, and not as motivated as I used to be! Thanks for the opti! :)

C, 64 bytes
Call f() with the string to square.
m;f(char*s){for(m=sqrt(strlen(s));*s;s+=m)printf("%.*s\n",m,s);}

Try it on ideone.

Can you make it work with implicit int argument instead of char*?

I don't think so. It needs to be dereferenced, so a numeric type won't work, and it can't be an int* since that would scale wrong when adding.

Suggest s+=write(puts(""),s,m)); instead of s+=m)printf("%.*s\n",m,s);

Python, 94 75 71 65 63 bytes
import re;lambda r:"\n".join(re.findall("."*int(len(r)**.5),r))

Old version:
lambda r:"\n".join(map("".join,zip(*[iter(r)]*int(len(r)**.5))))

Note that you can use input() by default to receive input in quotes, unless you want to specifically remove that option.

@xnor Oh wow, a few days ago I was wondering if I could use quotes on input...

Wouldn't it be shorter to use a lambda?

@LeakyNun true...

05AB1E, 8 6 bytes
Thanks to @quartata for letting me know about the square-root function
Dgtô¶ý

Try it online!
Explanation
D     Implicit input. Duplicate
g     Number of elements
t     Square root
ô     Split into chunks of that length
¶     Push newline character
ý     Join list by newlines. Implicit display

Very nice! Also, « is short for joining on newlines :).

@Adnan Thanks! Now I have outgolfed myself :-D

I have rolled back to my 6-byte version because there was a previous answer with «

Oh, that's too bad :(

Does anyone else feel like those languages specifically created for code golf are kinda ruining the appeal of this whole thing?

@RenéRoth Apparently yes. I don't necessarily agree with that position, though :-)

Cheddar, 27  bytes
s->s.chunk(s.len**.5).vfuse

I added the .chunk function a while ago but I removed it in the transition to the new stdlib format and forgot to re-add it. Cheddar has a dedicated sqrt operator but **.5 is shorter
Try it online!
Explanation
s ->              // Function with argument s
    s.chunk(      // Chunk it into pieces of size...
      s.len ** .5 // Square root of length.
    ).vfuse       // Vertical-fuse. Join on newlines

zsh, 36 33 bytes
fold -`tr -d .<<<$[$#1**.5]`<<<$1

Try it online!
Takes input as a command line argument, outputs to STDOUT.
                   $#1             # get the length of the input string
                 $[   **.5]        # take it to the .5 power (sqrt)
              <<<                  # and pass the result to
       tr -d .                     # tr, to delete the trailing decimal point
                                   #    (sqrt(9) is 3. instead of 3)
     -`                    `       # give the result as a command line flag to
fold                               # the fold util, which wraps at nth column
                            <<<$1  # pass the input as input to fold

+1 for having your score be n².  Mine is too :)

@DigitalTrauma Should you retract your upvote now?

Dyalog APL, 10 bytes
⊢⍴⍨2⍴.5*⍨≢

Explanation:
         ≢   length of the argument
     .5*⍨    square root
   2⍴        reshape that to a length-2 vector
⊢⍴⍨          reshape the input by that vector

Tests:
      (⊢⍴⍨2⍴.5*⍨≢)'Hi, world'
Hi,
 wo
rld
      (⊢⍴⍨2⍴.5*⍨≢)'Hi, world! Hello'
Hi,
worl
d! H
ello
      (⊢⍴⍨2⍴.5*⍨≢)'Lorem ipsum dolor sit amt'
Lorem
 ipsu
m dol
or si
t amt
      (⊢⍴⍨2⍴.5*⍨≢) 'H'
H

CJam, 8 bytes
l_,mQ/N*

Try it online!
Explanation
l     e# Read line from input
_,    e# Duplicate. Get length
mQ    e# Integer square root
/     e# Split into pieces of that size
N*    e# Join by newline. Implicitly display

Pyth, 8 bytes
jcs@lQ2Q

Try it online
How it works
    lQ     length of input
   @  2    square root
  s        floor
 c     Q   chop input into that many equal pieces
j          join on newline

Bash + GNU utilities, 25
fold -`dc -e${#1}vp`<<<$1

Not so different to @Doorknob's answer, but dc is a shorter way to get the square root.

, 11 chars / 14 bytes
ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).
Generated using this code (run in the interpreter's browser console):
c.value=`Ѩ${alias(_,'chunk')}(ï,√ ïꝈ⸩${alias(Array.prototype,'mjoin')}⬮`

Brainfuck, 83 bytes
,[>+[>+<-],]
>
[
  >>[<+<-->>-]
  +<[>+<-]
  <-
]
<<
[
  [<]
  >.,
  >[>]
  >>+>-[<]
  <[[>+<-]++++++++++.,<<]
  <
]

Try it online!
This uses the same idea as Leaky Nun's answer. He asked for help golfing it in chat, then suggested that I add this as a new answer. (Actually what I wrote in chat was an 84-byte solution very similar to this.)
For the sake of comparison, an extra > is needed at the beginning for brainfuck implementations that don't allow negative memory addresses.
As expected, this finds the length of the input, then takes the square root, then prints the lines accordingly. It takes advantage of perfect squares being partial sums of 1 + 3 + 5 ....

Brain-Flak, 110 96 bytes
([]<>){({}{}(({}[()])))}{}{({}()<(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>)>)}{}{}{({}<>)<>}<>

Try it online!
Second solution, 96 bytes
(([]<>)<{({}({})({}[()]))}{}>){({}(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>))}{}{}{({}<>)<>}<>

Try it online!
Explanation
Here I explain the first solution, both are the same length but I like the first one because it is cooler and employs some nice tricks.
The most important part of the code is a modified square root function I wrote some time ago.  The original version was
{({}[({})({}())])}{}

And this works, but we actually want two copies of the negative square root.
Why?  We need two copies because we are looping through the string at two levels, one to make the lines and one to count the number of lines.  We want it to be negative because looping with negatives is cheaper.
To make this negative we move around the [...] so it looks like this
{({}({})({}[()]))}{}

To make two copies we change when pops occur
{({}{}(({}[()])))}{}

Now that we have that bit we can put it together with a stack height to get the first chunk of code we need.
([]<>){({}{}(({}[()])))}{}

We move to the offstack because our square root function needs two free zeros for computation, and because it makes stuff a little bit cheaper int he future in terms of stack switching.
Now we construct the main loop
{({}()<(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>)>)}{}{}

This is pretty straight forward, we loop n times each time moving n items and capping it with a new line (ASCII 10).
Once the loop is done we need to reverse the order of our output so we just tack on a standard reverse construct.
{({}<>)<>}<>

Also 96

PHP, 51 bytes
<?=join("
",str_split($x=$argv[1],strlen($x)**.5));

Perl 6, 38 bytes
$_=get;.put for .comb: .chars.sqrt.Int

Explanation:
$_ = get;          # get a single line of input

$_.put             # print with trailing newline

for                # every one of the following:

$_.comb:           # the input split into

$_.chars.sqrt.Int  # chunks of the appropriate size

Ruby -p, 40 33 30 bytes
-7 bytes from @Jordan.
gsub(/#{?.*~/$/**0.5}/){$&+$/}

Try it online!

Cheddar, 57 bytes
n->(m->(|>m).map(i->n.slice(i*m,i*m+m)).vfuse)(n.len**.5)

Since variables are broken, I would have to pass in variables through lambda application.
Also, it turns out that even if variables worked, it would still be shorter to use lambda application.
Usage
cheddar> (n->(m->(|>m).map(i->n.slice(i*m,i*m+m)).vfuse)(n.len**.5))("abcd")
"ab
cd"

Pyke, 5 bytes
l,fnJ

Try it here!

PowerShell, 56 58 61 bytes
param($i)$i-replace".{$([Math]::Sqrt($i.Length))}",'$&
'

Taking it as a param saves two bytes

Java 1.7, 110 bytes
void f(String s){for(int i=-1,k=(int)Math.sqrt(s.length());++i<k;)System.out.println(s.substring(i*k,i*k+k));}

Try it! (Ideone)
I tried another approach with a function returning the result as a string, but just having to declare the string and the return statement is already more expensive (byte-count-wise) than the print statement.
Gotta love Java's verbosity... :)

Nice answer +1. You can golf it by 1 byte by using i=0, i<k and s.substring(i*k,i++*k+k) instead of i=-1, ++i<k, s.substring(i*k,i*k+k). Also, usually we use just Java 7 instead of Java 1.7, but it's good that you've added it, a lot of people forget to do so.

R, 59 54 bytes
function(s)write(el(strsplit(s,'')),1,nchar(s)^.5,,'')

Try it online!
Prints with a trailing newline. Surprisingly short, considering how badly R handles strings.

K (ngn/k), 11 bytes
{(2#%#x)#x}

Try it online!

the bracketed expression returns list 5 5 for input "Lorem ipsum dolor sit amt". it reads "2 take sqrt count x", where x is the string argument. then (5 5)#x means "cut x into 5 lists each of length 5". with this we get:
  {(2#%#x)#x}"Lorem ipsum dolor sit amt"
("Lorem";" ipsu";"m dol";"or si";"t amt")

Vyxal jr, 3 bytes
L√/

Try it Online!
  / # (Implicit input) divided into...
 √  # Square root of...
L   # Length of...
    # (implicit input)
  / # Pieces.

Risky, 14 bytes
2_2+_2+__1+_1*__?*_1/}!?*_1

Try it online!
Explanation
So many no-ops... 0__0
Parse tree:
             *
      +             /
2      _      _      }
   +      +      *      *
 _  _   _  _   _  _   !  _
  2  2   1  1   ?  1   ?  1

How it works:
                ?            The input string (as a list of charcodes)
              __ *_1         (no-ops)
                    /        Group into sublists of length...
                     }       square root of...
                      !      length of...
                       ?     the input string again
                        *_1  (no-ops)
2_2+_2+__1+_1                Generate the number 10 in a needlessly complicated way
             *               Join the list of lists on 10 (newline)
                             Output the resulting list of numbers as a string

Convex, 7 bytes
_,mQ/N*

Try it online!
Fun fact:
_,mQ/\* also works on TIO due to how it works.
How have I forgotten to make a 1-char square root op?

Matlab, 28 bytes
@(s)reshape(s,nnz(s)^.5,[])'

reshape puts output in columns first, so we have to transpose the whole thing to get the desired output.

QBasic, 60 bytes
Nothing special here... just your BASIC program.
INPUT i$
t=SQR(len(i$))
FOR x=0TO t-1
?MID$(i$,x*t+1,t)
NEXT

PHP, 47 bytes
<?=chunk_split($a=$argv[1],strlen($a)**.5,"
");

For multibyte strings, 66 bytes
<?=preg_replace("/.{1,".sqrt(strlen($a=$argv[1]))."}/u","$0
",$a);

Silicon, 6 bytes
I added some commands right after I noticed this challenge.
iLqnåê

Explanation:
iLqnåê

i          Input
  q        Square root of...
 L         Length
   n       Convert to integer
    å      Split into chunks of n
     ê     Join at newlines

q/kdb+, 25 22 bytes
Solution:
-1{(2#6h$sqrt(#)x)#x};

Example:
q)-1{(2#6h$sqrt(#)x)#x}"Lorem ipsum dolor sit amt";
Lorem
 ipsu
m dol
or si
t amt

Explanation:
-1{(2#6h$sqrt count x)#x}; / ungolfed solution
  {                     }  / lambda function
                      #x   / take from x (input)
   (                 )     / do everything in the brackets first
              count x      / length of x
         sqrt              / calculate square-root
      6h$                  / cast to integer
    2#                     / duplicate this number, e.g. 5->(5;5)
-1                       ; / print to stdout

SOGL V0.12, 1 byte
√

Try it Here! - this expects the input on the stack as a function, so there it's called as a function F and then, in the next line, , pushes the input and F executes the function.
without builtins, 3 bytes
l√n

Try it Here!
push length, square root it, split input into strings of that length, implicitly output joined with newlines

Perl 6, 28 27 bytes
-1 byte thanks to nwellnhof
{.comb(.comb**.5+|0)>>.say}

Try it online!

**.5 (or **½) is one byter shorter than .sqrt.

@nwellnhof I always forget about that! Wouldn't it be nice if we could use the √ symbol instead?

Momema, 99 bytes
03i00+1*0*0*-9i=+1**00+-4*0q00+*0-+1+*1*1 1+1*1q=*02*1o03*1p0-9*+4*00+1*03+-1*3p=*3 2+-1*2-9 10o=*2

Try it online!
Explanation
                 # -- Read the input onto the tape.
                 # -- Set aside the first 4 cells as variables.
0   3            # p = 3
i   0            # do {
0   +1*0         #   p = p+1
*0  *-9          #   tape[p] = getchar()
i   =+1**0       # } while (tape[p] != -1)
0   +-4*0        # p = p - 4
                 # -- Calculate the square root of the input length.
q   0            # do {
0   +*0-+1+*1*1  #   p = p - (1 + r + r)
1   +1*1         #   r = r + 1
q   =*0          # } while (p)
                 # -- Print the formatted output.
2   *1           # i = r
o   0            # do {
3   *1           #   j = r
p   0            #   do {
-9  *+4*0        #     putchar(tape[p + 4])
0   +1*0         #     p = p + 1
3   +-1*3        #     j = j - 1
p   =*3          #   } while (j)
2   +-1*2        #   i = i - 1
-9  10           #   putchar(10)
o   =*2          # } while (i)

Python 3.8, 68 bytes
a=int(len(s:=input())**.5)
for i in range(0,a**2,a):print(s[i:][:a])

Not the shortest Python answer, but also not the longest. Goes through the string by intervals of the square root of the length of the string. I saved a byte by using Python 3.8's new-fangled assignment expressions.

Kotlin, 57 bytes
fun String.s()=chunked(sqrt(length+.0).toInt(),::println)

Explanation:
fun String.s()=   # Extension method on the string, so we can avoid declaring a param
chunked           # Actually this method does all the heavy lifting, it splits the string into a list of size N strings
(sqrt(length+.0)  # Kotlin's sqrt only takes double and produces double :/
.toInt(),         # So we need to cast the result for chunked in an ugly way :/
::println)        # But hey, applying a transform to print is actually included for free!

Python 3, 78 bytes
def f(s):
	r=int(len(s)**.5)
	return'\n'.join([s[i*r:i*r+r]for i in range(r)])

Try it online!

Stax, 3 bytes
:Jm

Run and debug it at staxlang.xyz!
Very simple. :J squarifies an array. That m is necessary because Stax will print a list of strings on one line.
Without the builtin, six bytes
c%|q/m

Run and debug it at staxlang.xyz!
Copy the string (c) and take its length (%). Square root that length (|q), and split the string into substrings of that (square-rooted) length (/).

TI-Basic, 33 Bytes
Input Str1
length(Str1→Z
For(X,1,Z,√(Z
Disp sub(Str1,X,√(Z
End

This is not a particularly interesting answer, due to the limitations of TI-Basic, but I like the language too much to resist. Note that TI-Basic is tokenized, so byte count for the program is not the same as character count.

Zsh, 54 51 bytes
-3 by ^= instead of =0^().
((n=$#1,l^=n**0.5))
eval '<<<${1:'{0..$n..$l}':$l}'

Try it online!
Try it online!
Shoutouts to eval jank.
((n=$#1,l^=n**0.5))              # the xor with 0 casts n**0.5 to an integer
eval '<<<${1:'           ':$l}'  # when eval'd, prints a subtring of length l
              {0..$n..$l}        # brace expansion: {0..4..16} => 0 4 8 12 16

I left in set -x in the TIO link, scroll down to the debug section to see exactly what happens with the brace expansion.

Vyxal j, 1 byte
²

Try it Online!
Yes, there's a built in for it.
"But there's already another vyxal answer!" This is using 2.16.0 while the other one is using <2.4.0

ListSharp, 157 bytes
STRG a=READ[<here>+"\\a.txt"]
NUMB b=(int)Math.Sqrt(a LENGTH)
[FOREACH NUMB IN 0 TO b-1 AS x]
{
STRG t=GETRANGE a FROM [x*b+1] TO [x*b+b]
ROWS f=f+t
}
SHOW=f

reads text from local file a.txt , im using embedded c# code and other tricks to make this work. feel free to ask me questions about this code or listsharp in general

C, 64 bytes
f(s,m,k){for(m=k=sqrt(strlen(s));k--;s+=m)printf("%.*s\n",m,s);}

Inspired by the other C answer.
Only works on platforms where int has the same size as char* (e.g. 32-bit Windows).

Lua, 68 Bytes
o=io.read()for s in o:gmatch(("."):rep(math.sqrt(#o)))do print(s)end

Simple and dirty, just how I like it.
I use o=io.read() instead of function(o) Which works out as the same length, to save from having to add an extra "end" at the end.
Pretty simple in functionality, it just uses gmatch to loop through the string in chunks of math.sqrt(#o), Which is the square root of the length of the string. Sadly, Lua patterns don't offer the regex functionality of {} to denote a specific count, so I had to do :rep() instead.

Racket 102 bytes
(λ(s)(let*((l(string-length s))(q(sqrt l)))(for((i(range 0 l q)))(displayln(substring s i(+ i q))))))

More readable form:
(define (f s)
  (let* ((l (string-length s))
         (q (sqrt l)))
    (for((i(range 0 l q)))
      (displayln (substring s i(+ i q))))))

Testing:
(f "Lorem ipsum dolor sit amt")
Lorem
 ipsu
m dol
or si
t amt

ISOLADOS, 93 bytes
ISOLAAAADOS ISOLAAAAAADOS ISOLAAAAAAAADOOS ISOLAAADOOOOOOS ISOLAAAAAAAADOOOS ISOLAAAAAAAAADOS

ISOLAAAADOS          input
ISOLAAAAAADOS        duplicate
ISOLAAAAAAAADOOS     length
ISOLAAADOOOOOOS      square root
ISOLAAAAAAAADOOOS    a split into chunks of length b
ISOLAAAAAAAAADOS     join by new lines

QBIC, 41 bytes
;c=sqr(len(A))[1,c|?mid$$|(A,q,c) q=c*a+1

Unfortunately, it doesn't work on text parameters with spaces in it. I'll put it on the QBIC todo-list.
Explanation:
;           gets the input as string A$
sqr(len(A)) calls the QBasic square root function, with the length of A$ as argument
[1,c...     Loops from 1 to the height of the square
?mid$$|(..) Prints the middel part of A$. The '$' has a reserved meaning in QBIC and needs to be escaped
q=c*a+1     Sets the starting point of the next mid$
<implicit>  NEXT

Note that a more modern version of QBIC can solve this in 27 bytes:
_L;|g=sqr(a)[1,a,g|?_sA,b,g

Improvements are: inline cmd-arg-grabbing (;), implementation of len (_L or _l) and substring (_s). Also, I've improved conditions and workings of the FOR-loop itself.

Japt -R, 7 6 4 bytes
òUÊ¬

Try it
òUÊ¬     :Implicit input of string U
ò        :Partition into chunks of length
 UÊ      :  Length of U
   ¬     :  Square root
         :Implicitly join with newlines and output

K (oK), 14 bytes
Solution:
`0:#[2#%#x]x:;

Try it online!
Example:
`0:#[2#%#x]x:"Lorem ipsum dolor sit amt";
Lorem
ipsu
m dol
or si
t amt

Explanation:
Similar to my q/kdb+ solution, but a little shorter. Use # to reshape string into a square:
`0:#[2#%#x]x:; / the solution
`0:          ; / print to stdout and swallow return value
           x:  / save input as x
   #[     ]    / reshape
        #x     / count x
       %       / sqrt
     2#        / duplicate

Ly, 31 bytes
irysp>l12/^s<[ol,s!['
o>s<1$]p]

Try it online!
Try a square version online, for fun

JavaScript (Node.js), 54 bytes
s=>[...s].map((c,i)=>++i%s.length**.5?c:c+`\n`).join``

Try it online!

Python 3, 76 bytes
I understand the length of my answer, but I didn't want to copy off the other people that did python, so I took the bit longer route (by like an extra 20 some bytes).
i=input()
for c in range(len(i)):print(i[c],end="\n"*((c+1)%len(i)**0.5==0))

Try it online!
So rather than cut my string after I use the part I want, I keep printing characters until I get to the edge of the square, then I add a newline and keep spewing characters and doing that till we get to the end.

C#, 151 Bytes
static string T(string c){string s="";int a=(int)Math.Sqrt(c.Length);for(int i=0;i<c.Length;i++){s=s+c.Substring(0,a)+"\n";c=c.Remove(0,a);}return s;}

Japt -R, 4 bytes
òUÊq

Try it online!
Explanation:
òUÊq
ò        // Split the input into slices of length:
   q     //   Square root of
 UÊ      //   Length of the input
-R       // Join with newlines

Tcl, 100 98 65 bytes
{s {regsub -all -- (.{[expr int([string le $s]**.5)]}) $s \\1\n}}

Try it online!

Lua, 65 bytes
t=io.read()for i in t:gmatch(('.'):rep((#t)^0.5)) do print(i) end

Try it online!
Explanation:
t=io.read()           -- Read input string
for i in              -- Iterator-based loop
    t:gmatch(         -- over results of pattern-matching on input
        ('.'):rep(    -- Make string of dots
            (#t)^0.5) -- square root from input length string long
        )             -- …which is a pattern for matching that long substring
    )
do                    -- Loop body
    print(i)          -- Print our match and newline
end

TL;DR: it uses pattern-matching (Lua version of regexp) to get square root of input long substrings and prints them.
Lua, 84 bytes (with UTF-8 support)
t=io.read()for i in t:gmatch(('.[\128-\191]*'):rep(utf8.len(t)^0.5)) do print(i) end

Try it online!
Same idea as above, but with few UTF-8 tricks.

Runic Enchantments, 19 bytes
qA,r\;>i:l͍'
$ka$L

Try it online!
Outputs with a trailing newline because its cheaper to loop and wait for stack underflow to cause program termination than to figure out if anything's left on the stack to print. As such the required terminator ; goes unexecuted.
Inputs that are not capable of being square are output as tall rectangles, as computation required to coerce a square through trailing spaces aren't necessary due to challenge spec regarding inputs.
Additionally, spaces need to be escaped in order for the input to be treated as a single string (rather than multiple space-separated strings).

Elm 0.19, 112 bytes
import List.Extra as L
s l=List.concat<|List.intersperse['\n']<|L.groupsOf(floor<|sqrt<|toFloat<|List.length l)l

Input and output as a list of characters. See it working here.

C#, 180 bytes
using System;public class P{public static void Main(string[]a){var d=(int)Math.Sqrt(a[0].Length);string f="";for(int i=0;i<d;i++){f+=a[0].Substring(i*d,d)+"\n";}Console.Write(f);}}

Try Online

MathGolf, 5 bytes
h√i/n

Try it online!
Unnecessarily long, the i shouldn't be needed in my opinion. For operators where float behavior is undefined, the float is normally cast to an integer and used in the operation. This seems to be forgotten for string division, which leads to the extra byte.
Explanation
h       length of array/string without popping
 √      pop a : push(sqrt(a))
  i     convert to integer
   /    split strings
    n   map array with newlines

Python 3, 54 bytes
lambda s:fill(s,int(len(s)**.5))
from textwrap import*

Try it online!
In Python 3 the textwrap module can be used to perform this task.

Factor + math.unicode, 39 38 bytes
[ dup length √ 1 /i group "\n"join ]

Try it online!
Explanation:

dup Duplicate the input.
Stack: (e.g.) "Hi, world" "Hi, world"

length Get the length.
Stack: "Hi, world" 9

√ Take the square root.
Stack: "Hi, world" 3.0

1 /i Convert to an integer. This is shorter than >integer.
Stack: "Hi, world" 3

group Split a sequence into groups indicated by the integer on top of the data stack.
Stack: { "Hi," " wo" "rld" }

"\n"join Join each string in a sequence into a newline-delimited string.
Stack: "Hi,\n wo\nrld"

Canvas, 3 bytes
ｌ√ｎ

Try it here!
Ties Vyxal  and uses pretty much the same approach but without those icky yucky awful terrible flags.

Brachylog, 7 bytes
ẹġṁcᵐẉᵐ

Try it online!
Explanation
ẹ        Convert the input string into a list of characters
 ġ       Split that list into groups of equal length
  ṁ      The result must be a square matrix
   cᵐ    Concatenate each row back into a string
     ẉᵐ  Print each row with a trailing newline

The solution would be 5 bytes if lists of lines were acceptable output, or 3 bytes if a list of lists of characters were acceptable.

Thunno 2 N, 3 bytes
lƭ/

Attempt This Online!
Explanation
lƭ/  # Implicit input
l    # Length of input
 ƭ   # Square root
  /  # Split into that
     # many pieces
     # Implicit output,
     # joined on newlines


text:
A Formula for Congruences
The Chinese Remainder Theorem can be quite useful in modular arithmetic.
For example, consider the following set of congruence relations:

For sets of congruence relations like this, where all the bases (3, 5, 7 in this example) are co-prime with each other, there will be one and only one integer n between 1 and the product of the bases (3*5*7 = 105 in this example) inclusive that satisfies the relations.
In this example, the number would be 14, generated by this formula:

where 2, 4, and 0 are given from the above example.
70, 21, 15 are the coefficients of the formula and they are dependent on the bases, 3, 5, 7.
To calculate the coefficients of the formula (70, 21, 15 in our example) for a set of bases, we use the following procedure.
For each number a in a set of bases:

Find the product of all of the other bases, denoted as P.
Find the first multiple of P that leaves a remainder of 1 when divided by a. This is the coefficient of a.

For example, to calculate the coefficient that corresponds to the base 3, we find the product of all the other bases (i.e. 5*7 = 35) and then find the first multiple of that product that leaves a remainder of 1 when divided by the base.
In this case, 35 leaves a remainder of 2 when divided by 3, but 35*2 = 70 leaves a remainder of 1 when divided by 3, so 70 is the corresponding coefficient for 3. Similarly, 3*7 = 21 leaves a remainder of 1 when divided by 5 and 3*5 = 15 leaves a remainder of 1 when divided by 7.
In a nutshell
For each number a in a set of numbers:

Find the product of all of the other numbers, denoted as P.
Find the first multiple of P that leaves a remainder of 1 when divided by a. This is the coefficient of a.

The challenge

The challenge is, for a set of two or more bases, to find the set of corresponding coefficients.
The set of bases are guaranteed to be pairwise co-prime and each base is guaranteed to be larger than 1.
Your input is a list of integers as input [3,4,5] or space-separated string "3 4 5" or however your inputs work.
Your output should either be a list of integers or space-separated string that denotes the set of coefficients.

Test cases
input             output
[3,5,7]           [70,21,15]
[2,3,5]           [15,10,6]
[3,4,5]           [40,45,36]
[3,4]             [4,9]
[2,3,5,7]         [105,70,126,120]
[40,27,11]        [9801,7480,6480]
[100,27,31]       [61101,49600,56700]
[16,27,25,49,11]  [363825,2371600,2794176,5583600,529200]

Many thanks to Leaky Nun for his help in writing this challenge. As always, if the problem is unclear, please let me know. Good luck and good golfing!

Will there always be 3 numbers in the input?

@xnor Nope. Test cases edited.

Haskell, 61 55 53 bytes
f x=[[p|p<-[0,product x`div`n..],p`mod`n==1]!!0|n<-x]

Defines a function f that takes input and gives output as a list of integers.
f x=[                                          |n<-x]  (1)
              product x                                (2)
                       `div`n                          (3)

First we loop over all integers in the input (1). Then we take the product of all of the integers (2) and divide by n to get just the product of the non-n integers, which is P (3).
           [0,               ..]                       (4)
     [p|p<-                     ,p`mod`n==1]           (5)
                                            !!0        (6)

Then we use the result (P) as the step value for a range starting at zero (4). We take the result, [0, P, 2P, 3P, ...], and filter it on values for which the result of a mod-n operation is one (5). Finally, we take the first element, which works thanks to lazy evaluation (6).
Thanks to @xnor for 2 bytes!

Welcome to haskell! I think your quot can be a div, and head can be !!0.

Jelly, 11 7 bytes
P:*ÆṪ%P

Try it online! or verify all test cases.
Background
Let P and a be strictly positive, coprime integers.
The two-step process in the question – finding a multiple of P that leaves a remainder of 1 when divided by a – can be described by the following congruence equation.

By the Euler-Fermat theorem, we have

where φ denotes Euler's totient function. From this result, we deduce the following.

Finally, since the challenge requires us to compute Px, we observe that

where Pa can be computed as the product of all moduli.
How it works
P:*ÆṪ%P  Main link. Argument: A (list of moduli)

P        Yield the product of all moduli.
 :       Divide the product by each modulus in A.
   ÆṪ    Apply Euler's totient function to each modulus.
  *      Raise each quotient to the totient of its denominator.
     %P  Compute the remainder of the powers and the product of all moduli.

J, 13 bytes
*/|5&p:^~*/%]

Based on @Dennis' amazing answer.
Usage
Some test cases will need the input as extended integers which have a suffix x.
   f =: */|5&p:^~*/%]
   f 3 5 7
70 21 15
   f 40x 27 11
9801 7480 6480
   f 16x 27 25 49 11
363825 2371600 2794176 5583600 529200

Explanation
*/|5&p:^~*/%]  Input: list B
         */    Reduce B using multiplication to get the product of the values
            ]  Identity function, get B
           %   Divide the product by each value in B, call the result M
   5&p:        Apply the totient function to each value in B, call the result P
       ^~      Raise each value in M to the power of its corresponding value in P
*/             The product of the values in B
  |            Compute each power modulo the product and return

Try it here.

Mathematica, 27 bytes
PowerMod[a=LCM@@#/#,-1,#]a&

Pyth, 14 bytes
mhfq1%Td*R/*FQ

Test suite.
Naive implementation of the algorithm.

Python 2, 87 84 bytes
A simple implementation of the algorithm. Golfing suggestions welcome.
a=input();p=1
for i in a:p*=i
print[p/i*j for i in a for j in range(i)if p/i*j%i==1]

A full program would save 3 bytes.

Jelly, 14 13 bytes
P:×"Ḷð%"’¬æ.ḷ

Saved a byte thanks to @Dennis!
Uses the process described in the challenge spec. The input is a list of bases and the output is a list of coefficients.
Try it online or Verify all test cases.
Explanation
P:×"Ḷð%"’¬æ.ḷ  Input: a list B
P              Get the product of the list
 :             Divide it by each value in the B, call it M
    Ḷ          Get a range from 0 to k for k in B
  ×"           Vectorized multiply, find the multiples of each M
     ð         Start a new dyadic chain. Input: multiples of M and B
      %"       Vectorized modulo, find the remainders of each multiple by B
        ’      Decrement every value
               If the remainder was 1, decrementing would make it 0
         ¬     Logical NOT, zeros become one and everything else becomes 0
            ḷ  Get the multiples of M
          æ.   Find the dot product between the modified remainders and the multiples
               Return

JavaScript (ES6), 80 bytes
a.map(e=>[...Array(e).keys()].find(i=>p*i/e%e==1)*p/e,p=a.reduce((i,j)=>i*j))

I tried the extended Euclidean algorithm but it takes 98 bytes:
a=>a.map(e=>(r(e,p/e)+e)%e*p/e,p=a.reduce((i,j)=>i*j),r=(a,b,o=0,l=1)=>b?r(b,a%b,t,o-l*(a/b|0)):o)

If the values are all prime, ES7 can do it in 56 bytes:
a=>a.map(e=>(p/e%e)**(e-2)%e*p/e,p=a.reduce((i,j)=>i*j))

Python + SymPy, 71 bytes
from sympy import*
lambda x:[(prod(x)/n)**totient(n)%prod(x)for n in x]

This uses the algorithm from my Jelly answer. I/O is in form of lists of SymPy numbers.

Cheddar, 64 bytes
n->n.map(i->(|>i).map(j->(k->k%i>1?0:k)(n.reduce((*))/i*j)).sum)

I should add a .product which does .reduce((*)) for arrays...

GAP, 51 bytes
GAP has a function that can compute the motivating example with ChineseRem([2,5,7],[2,4,0]), but that still doesn't make it that easy to get the coefficients. We can get the n-th coefficient by using the list with a one in the n-th position and zeroes at the other positions as second argument. So we need to create these lists and apply the function to all of them:
l->List(Basis(Integers^Size(l)),b->ChineseRem(l,b))

Batch, 148 bytes
@set p=%*
@set/ap=%p: =*%
@for %%e in (%*)do @for /l %%i in (1,1,%%e)do @call:l %%e %%i
@exit/b
:l
@set/an=p/%1*%2,r=n%%%1
@if %r%==1 echo %n%

Actually, 14 bytes
This uses the algorithm in Dennis's Jelly answer. Another answer based on my Python answer is forthcoming. Golfing suggestions welcome. Try it online!
;π;)♀\;♂▒@♀ⁿ♀%

How it works
                 Implicit input a.
;                Duplicate a.
 π;)             Take product() of a, duplicate and rotate to bottom.
    ♀\           Integer divide the product by each element of a. Call this list b.
      ;♂▒        Take that list, duplicate, and get the totient of each element.
         @♀ⁿ     Swap and take pow(<item in b>, <corresponding totient>)
            ♀%   Modulo each item by the remaining duplicate product on the stack.
                 Implicit return.

Another answer based on my Python answer at 22 bytes. Golfing suggestions welcome. Try it online!
;π╖`╝╛╜\╛r*"╛@%1="£░`M

How it works
            Implicit input a.
;π╖         Duplicate, take product of a, and save to register 0.
`...`M      Map over a.
  ╝           Save the item, b, in register 1.
  ╛╜\         product(a) // b. Call it P.
  ╛r          Take the range [0...b].
  *           Multiply even item in the range by P. Call this list x.
  "..."£░     Turn a string into a function f.
              Push values of [b] where f returns a truthy value.
    ╛@%         Push b, swap, and push <item in x> % b.
    1=          Does <item> % b == 1?
            Implicit return.


text:
Medieval orthography
Task
Your task is to convert a text into medieval orthography.
Details

j is converted to i and J to I.
u and U at the beginning of words are converted to v and V respectively.
v and V at anywhere except the beginning of words are converted to u and U respectively.
s is converted to ſ (U+017F) unless at the end of the word or preceded by another s.

Specs

A word is defined as a sequence of letters in abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.
All words will have at least two letters.
The input will only consist of printable ASCII characters (U+0020 - U+007E).
There will be no occurrences of more than two consecutive s. That is, sss will not be a substring of the input.

Testcases
Individual words:
Input       Output
------------------------
Joy         Ioy
joy         ioy
Universe    Vniuerſe
universe    vniuerſe
Success     Succeſs
successfull ſucceſsfull
Supervise   Superuiſe
supervise   ſuperuiſe
Super-vise  Super-viſe
I've        I've
majors      maiors
UNIVERSE    VNIUERSE
0universe   0vniuerſe
0verify     0verify
I0ve        I0ve
_UU_          _VU_
_VV_          _VU_
ss_         ſs_

Whole paragraph:
Input:  Christian Reader, I have for thy use collected this small Concordance, with no small labour. For being to comprise much in little roome, I was to make choyse of the most principall and usefull places, and to rank them under such words as I thought most essentiall and materiall in the sentence, because the scant roome allotted unto me, would not permit that I should expresse them under every word in the verse, as it is the manner in large Concordances.

Output: Chriſtian Reader, I haue for thy vſe collected this ſmall Concordance, with no ſmall labour. For being to compriſe much in little roome, I was to make choyſe of the moſt principall and vſefull places, and to rank them vnder ſuch words as I thought moſt eſsentiall and materiall in the ſentence, becauſe the ſcant roome allotted vnto me, would not permit that I ſhould expreſse them vnder euery word in the verſe, as it is the manner in large Concordances.

The SHA-256 hash of the output of the last testcase is:
5641899e7d55e6d1fc6e9aa4804f2710e883146bac0e757308afc58521621644

Disclaimer
Medievall orthographie is not that conſtante. Pleaſe do not complayne if you ſhall ſee olde bookes with a different orthographie.

"You are allowed to use f instead of ſ in the output." So there's basically no incentive to use ſ since it takes more bytes.

@Fatalize Fair point. Removed that one.

@LeakyNun Can we then count ſ as 1  byte?

there is actually incentive in the form of ff being changed to fs in some algorithms if ſ was not used

@R.Kap Nope. – –

@PeterTaylor Clarified.

@PeterTaylor Thanks, added.

Shouldn't Super-vise become Super-viſe?

What do you mean by beginning and end of words? Does that mean the first characters, the first n characters, etc.?

@R.Kap Beginning means the first letter; end means the last letter (is this so ambiguous?)

@R.Kap Yes, fixed.

How about I0ve as a test case?

SED, 144 140 111 Bytes
saved 29 bytes thanks to NoOneIsHere
-r -e'y/j/i/g;y/J/I/g;s/ u/ v/g;s/ U/ V/g;s/^u/v/g;s/^U/V/g;s/([^s])s(\w)/\1ſ\2/g;s/(\w)v/\1u/g;s/(\w)V/\1U/g'

You brave, brave soul.

You can cut many bytes by using only 1 -e. Use ;s inbetween statements.

I didn't know you could do that. Thanks!!

Python 3 (128 126 bytes)
import re;lambda k:re.sub("(?<!s)s(?=[a-zA-Z])",'ſ',re.sub("(?i)j|(?<![a-z])u|(?<=[a-z])v",lambda c:chr(ord(c.group())^3),k))

chr(ord(c.group())^3) feels excessive to xor a single-character string, but maybe a real Pythonista can suggest a golf. However, it's very convenient that ^3 suffices to interchange i <-> j and u <-> v.
NB The only thing here which requires Python 3 is the Unicode character: Python 2 complains Non-ASCII character '\xc5' <snip> but no encoding declared.

You shouldn't use \b since \b uses the definition of a word which includes digits and underscores.

@LeakyNun, hmm. While I'm looking for a fix, could you please add some test cases?

@R.Kap. (?i).

@PeterTaylor Wait, what does that do?

@R.Kap, it makes the regex case-insensitive.

@PeterTaylor Oh really? Wow, I did not know that. Do you mind if I use that in my answer?

@R.Kap, you won't find it easy because the s match is case-sensitive. I can use it because I've split out into two replacements.

All words will have at least two letters. (since you didn't join chat, can't find you in chat)

@LeakyNun, are you telling me this because you want me to change some of the test cases or because you've found a bug in my code?

Because you added s_ as a testcase, which should really be undefined.

You can get this to work in python 2 by starting the file with the UTF-8 BOM 0xEF 0xBB 0xBF.

@xsot, this is a golf. If I can save 3 bytes by using a more recent version of the language, I will! But when I see answers which specify the version I'm curious to know what the new feature is which they rely on.

@PeterTaylor I just thought to mention it so that those competing in python 2 can use your submission as a goal to beat.

Retina, 55 54 50 bytes
T`jJvV`iIuU
Ti01`uUp`vVp`[a-z]+
s(s*[a-zA-Z])
ſ$1

Try it online! (The first line enables a linefeed-separate test suite.)

Python 3.5, 124 116 111 118 125 144 142 bytes:
import re;lambda k:re.sub("J|j|(?<![a-zA-Z])[uU]|(?<=[a-zA-Z])[Vv]|(?<!s)s(?=[a-zA-Z])",lambda g:dict(zip('jJuUvVs','iIvVuUſ'))[g.group()],k)

Well, this seems like the perfect job for regular expressions!

You can use J|j instead of [Jj]

JavaScript (ES6), 154
Using parseInt to identify alphabetic characters. Note: casually but luckily parseInt('undefined',36)|0 is < 0
s=>[...s].map((c,i)=>((n=v(c))-19?n==31&p>9?'uU':n!=30|p>9?c=='s'&s[i-1]!=c&v(s[i+1])>9?'?':c+c:'vV':'iI')[p=n,c<'a'|0],p=0,v=c=>parseInt(c,36)|0).join``

Less golfed
s=>
  [...s].map(
  (c,i)=>
  ((n=v(c))-19
  ?n==31&p>9
    ?'uU'
    :n!=30|p>9
      ?c=='s'&s[i-1]!=c&v(s[i+1])>9
        ?'ſ'
        :c+c
      :'vV'
  :'iI')[p=n,c<'a'|0],
  p=0,
  v=c=>parseInt(c,36)|0
).join``

Test

F=
s=>[...s].map((c,i)=>((n=v(c))-19?n==31&p>9?'uU':n!=30|p>9?c=='s'&s[i-1]!=c&v(s[i+1])>9?'ſ':c+c:'vV':'iI')[p=n,c<'a'|0],p=0,v=c=>parseInt(c,36)|0).join``

out=(a,b,c)=>O.textContent+=a+'\n'+b+'\n'+c+'\n\n'

ti='Christian Reader, I have for thy use collected this small Concordance, with no small labour. For being to comprise much in little roome, I was to make choyse of the most principall and usefull places, and to rank them under such words as I thought most essentiall and materiall in the sentence, because the scant roome allotted unto me, would not permit that I should expresse them under every word in the verse, as it is the manner in large Concordances.'
to='Chriſtian Reader, I haue for thy vſe collected this ſmall Concordance, with no ſmall labour. For being to compriſe much in little roome, I was to make choyſe of the moſt principall and vſefull places, and to rank them vnder ſuch words as I thought moſt eſsentiall and materiall in the ſentence, becauſe the ſcant roome allotted vnto me, would not permit that I ſhould expreſse them vnder euery word in the verſe, as it is the manner in large Concordances.'
r=F(ti)
out(to==r?'OK':'KO',ti,r)

test=`Joy         Ioy
joy         ioy
Universe    Vniuerſe
universe    vniuerſe
Success     Succeſs
successfull ſucceſsfull
Supervise   Superuiſe
supervise   ſuperuiſe
Super-vise  Super-viſe
I've        I've
majors      maiors
UNIVERSE    VNIUERSE
0universe   0vniuerſe
0verify     0verify
I0ve        I0ve
_UU_          _VU_
_VV_          _VU_
ss_         ſs_`
.split('\n').map(t=>{
  var [i,o]=t.split(/\s+/),r=F(i)
  out(o==r?'OK':'KO',i,r)
})
#O {width:90%; overflow:auto; white-space: pre-wrap}

JavaScript (ES6), 111 bytes
s=>s.replace(/[a-z]+/gi,w=>w.replace(/j|J|^u|^U|\Bv|\BV|ss|s(?!$)/g,c=>"iIvVuUſ"["jJuUvVs".search(c)]||"ſs"))

Explanation: Because JavaScript regexp has no lookbehind, I instead break up the string into words, which then allows me to use ^ and \B as negative and positive letter lookbehinds. ss is dealt with by matching separately, with the slightly awkward replacement expression which takes fewer bytes than either replacing only the first character of c or adding an extra s to both strings and using the matching substring.

c=>"iIvVuUſ"["jJuUvVs".search(c)]||"ſs" is nice.

CJam (89 88 bytes)
{32|_'`>\'{<*}:A;SqS++3ew{_1="jJuUvVs"#[-4_{_0=A!3*}_{_0=A3*}_{_)A\0='s=>268*}W]=~f^1=}%

Online demo
I never understood why CJam doesn't have regexes, but since it doesn't here's a solution which doesn't use them.

Ruby, 85 + 1 = 86 bytes
Run with ruby -p (+1 byte for p flag). Takes input on stdin.
gsub(/j|(?<=^|[^a-z])u|(?<=[a-z])v|(?<=^|[^s])s(?=[a-z])/i){$&.tr"jJsUuVv","iIfVvUu"}

Run the tests on ideone (wrapped in a lambda there because you can't give flags to ideone): http://ideone.com/AaZ8ya