[Question]
  [
**Closed**. This question is [opinion-based](/help/closed-questions). It is not currently accepting answers.
 
 
---
**Want to improve this question?** Update the question so it can be answered with facts and citations by [editing this post](/posts/2070/edit).
Closed 7 years ago.
[Improve this question](/posts/2070/edit) 
What are some tips for choosing the right language to golf?
What factors affect the language to be chosen?
Here are some example problem types:
* Problems that require *I/O* solution, either console or file
* Problems that require *parsing*
* Problems that requires you to write your solution as a *function definition*
* Math problems
* Problem dealing with prime numbers
* Solving number puzzles
* Performing numerical methods
* String processing
* Array processing
* Tricky 2D array problems
* Computational geometry
* Recursion
* 2D graphics
* 3D graphics
* Audio
* Networking / web
* Parallel processing
Don't simply say things like "Use GolfScript|J" because you like them. 
  
[Answer]
Putting my two cents in on *array programming languages*, **J** and **APL** in particular.
K/Kona, Q, and Nial fall in this category too, but they generally have the same benefits and criticisms. Use discretion. I will use J examples below, mostly because these are ASCII and thus easy to type--remember than APL characters count as single bytes, so don't let that be your problem with the language as choice for golfing.
* Math problems
* Solving number puzzles
* Performing numerical methods
* Tricky 2D array problems
These two are very good math and data-manipulation languages, because they toss arrays around a high level, and a lot of looping is done *implicitly*, by saying, e.g. add ten to each of 3, 4, and 5 (`10 + 3 4 5`) or sum each row of an array (`+/"1 arr`--the looping is in the `"1`).
* Problem dealing with prime numbers
With prime number problems in particular, J has fast and short builtin primitives, as do some dialects of APL. (Edit: I'm thinking of Nars2000, which is part dialect and part completely different implementation. APL has no builtin for primes.) N-th prime (`p:`), no. of primes up to (`_1&p:`), factoring (`q:`), GCD and LCM (`+.` and `*.`), and so on, there's a lot there. However, in practice, the question will often specify that you have to cook your own prime implementations, so these don't see too much use. There are still neat and fancy ways of getting the prime stuff you need, it just becomes a little less cut-and-paste.
* String processing
* Array processing
Array and string processing is a bit of a mixed bag: if it's something that APL/J is good at or has a primitive or common idiom for, it's nearly trivial; if it's something that's very sequential and not very parallelizable, you're going to have a bad time. Anything in between is up in the air, though usually they will respond favourably.
* Problems that require I/O solution, either console or file
* Problems that requires you to write your solution as a function definition
IO is weird. APL has a single-character input expression, but with J you have to spend at least 8 to read in a number: `".1!:1]1`. Output is a little less verbose, but you're still looking at 6 or 7 characters wasted, in practice. J in particular really likes it a lot if you can take in the input as arguments to a function, instead of having to muck around with IO itself.
In practice, with J and APL, usually the solution is written as a function that you invoke at the console. With APL, you can basically just put in variable names for your arguments and wrap the expression you were working with in curly braces and call it a day.
But with J, there's a bit of an overhead for defining functions explicitly--`3 :'...'`, and you have to escape any strings inside--so what is usually done is something called tacit programming: you program at the function level, combining primitives in a manner not unlike that of Haskell. This can be both a blessing and a curse, because you don't have to spend as many characters referring to your arguments, but it's easy to drown in parentheses and end up losing tens of characters trying to hack your otherwise short and clever solution into something that works.
* Problems that require parsing
* Computational geometry
I don't have experience with golfing these particular problems, but I will say this: in the end, array programming languages are very good at piping and transforming lots of data in the same way. If you can turn the problem into an exercise in number shuffling, you can make it an APL/J problem, no sweat.
That said, not everything is an APL/J problem. Unlike Golfscript, APL and J just happened to be good for golfing, alongside their other benefits ;)
[Answer]
Why hasn't Perl been praised yet? It's an excellent golfing language, for nearly every one of these, especially string related stuff (regex).
Burlesque is good for number-related programs, while Ruby is great for simpler text manipulation.
There's actually a list of languages and golfing scores over [here](http://golf.shinh.org/lranking.rb).
[Answer]
I like using obscure programming languages to (try to) get the job done. 
Here are my favorites for the details you listed:
**Problems that require I/O solution, either console or file**
Languages like *TI-Basic* work well, but I prefer *Ruby* because of `puts`
**Problems that require parsing**
*GolfScript* will definitely aid you here
**Problems that requires you to write your solution as a function definition**
*TI-84 Table* - allows functions as `Y=` e.g. `Y=|X|` returns the absolute value of X
**Math problems**
*TI-Basic* - made for a calculator, so it includes math ;)
**Problem dealing with prime numbers**
Nothing special; *Mathematica* is probably the right tool for the job
**Solving number puzzles**
*TI-Basic* as it automatically loops through arrays
**Performing numerical methods**
*TI-Basic* or *Mathematica*
**String processing**
*Python* - has some great string functions. 
No matter how good you think *TI-Basic* is, **don't use it** for strings...
**Array processing**
*TI-Basic* - **automatically loops through arrays**; e.g. increment all values in the array - `L1+1→L1`
*Ruby* - also has very powerful array features, and of course the `!` will help compress code also
**Tricky 2D array problems**
*Ruby* or *Python* works best here, as *TI-Basic* doesn't support 2D arrays
**Computational geometry**
*TI-Basic* has geometric features and can be used for most math up to Calculus and Linear Algebra
---
***BONUS***
**Looping**
Either [*Arduino*](http://www.arduino.cc/ "Arduino") or [*Quomplex*](http://timtechsoftware.com/?page_id=1264 "Quomplex"). *Arduino* has a built-in `void loop(){}` and *Quomplex* has the infinite loops contained by brackets (`[]`)
**Drawing/GUI**
[*Game Maker Language*](http://yoyogames.com/ "YoYo Games") has **very** powerful drawing features, and *TI-Basic* is also a generally useful tool because of the support for drawing on the graph.
**Quines**
Either *HQ9+* or *Quomplex* because *HQ9+* has the `Q` to output the program's source code and *Quomplex* will automatically print out its source code unless `*` (output) is specified or it produces no output, defined with `#`
[Answer]
If you're solving a math problem and you don't have Mathematica, try [Sage](http://www.sagemath.org/). It is based on Python, so if you already know Python you don't need much time to learn its syntax.
Examples:
* [Solving a system of linear equations](https://codegolf.stackexchange.com/a/22574/12205)
* [Primes](https://codegolf.stackexchange.com/a/22961/12205)
* [Base conversions](https://codegolf.stackexchange.com/a/22454/12205)
* [Drawing Platonic solids](https://codegolf.stackexchange.com/a/22764/12205)
It is also useful for graph plotting and equation solving (e.g. you can use the `solve()` function in Sage, or if that is forbidden by the rules, it allows an easy implementation of the Newton Raphson process because it has the `diff()` function that can perform symbolic differentiation).
Besides, if you are a Python2 programmer, using Sage may allow you to cheat by skipping the long `import` statements. For example, `math` and `sys` are already imported by default. (Note that this may not work if your Python2 program depends on integer division.)
[Answer]
I know three languages - Java, C++, and Python 3. I know none of these at a high level, but this is my experience with them.
## Java:
I would never use Java for golfing again. It takes over 80 characters just to write `Hello World!`. However, it does have its strengths:
> 
> Input requires creation of a `Scanner` object. It is difficult to input a single character. It requires specification of what types you are inputting.  
> 
>  Parsing is simple enough because of the `for` loop. The enhanced `for` loop is excellent for this.  
> 
>  Java supports methods, but the method declaration is quite long.  
> 
>  Java is excellent at math, as well as all other high-level languages.  
> 
>  Java is difficult to use when the problem involves modifying strings. You cannot make modifications to an existing string.  
> 
>  Java's arrays are simple to use.  
> 
>  Java is good at recursion.  
> 
>  Java includes built-in graphics. They are very easy to use.
> 
> 
> 
## C++
C++ is a very strong language, but it is somewhat lengthily when trying to golf at 56 characters for `Hello world!`.
> 
> Input and output are easy. You need not specify what types you are inputting - that is done automatically. However, you must include the iostream library.  
> 
>  Parsing is very easy.  
> 
>  Function declaration is simple, but eats a lot of important characters.
>  C++ excels at math, but it does not include PI or E, as Java does.  
> 
>  C++'s strings are easy to use and change as needed.  
> 
>  I use `vector`s where possible instead of `array`s, but both are easy to use.  
> 
>  C++ is good at recursion.  
> 
>  C++ does not include built-in graphics.
> 
> 
> 
## Python 3
Python 3 is similar to C++ and Java. It is much shorter as it is not strongly-typed - in other words, it just guesses at what the variables are.
> 
> Input is easy, but everything is input as strings. You must manually convert all input to whatever values you want.  
> 
>  Parsing and looping is very simple.  
> 
>  Python function declarations are quite simple and short.  
> 
>  Python is good at math.  
> 
>  Python's strings are simple to use.  
> 
>  Arrays are simple to use.  
> 
>  Python is good at recursion.  
> 
>  Python does not include built-in graphics.
> 
> 
> 
[Answer]
Depends on what one needs, C/C++ is fast, but you have to code more of the work yourself.
Python and Ruby are slower but are a lot easier to code with built in methods that shortens a lot of work and they automatically handle infinitely large values (if one has the RAM). 
Using a functional language like Haskell is great for purely mathematical functional use if one can frame the problem that way.
]