text:
Is this a three-digit number ending in one?
Given a nonnegative integer, return whether it is a three digit number ending in one, in any consistent integer base. In other words, the number needs to be represented in base-N, N being an integer greater than zero.
Rules

This is code-golf, so shortest answer wins.
Since unary behaves weirdly, the behavior with input 310 is undefined.
Standard loopholes are prohibited.

Examples
True:
5
73
101
1073
17
22
36
55
99

False:
8
18
23
27
98
90
88
72
68

A handful of large numbers:
46656 true
46657 true
46658 true
46659 true
46660 true
46661 false
46662 false
46663 true
46664 false
46665 true
46666 true
46667 false
46668 false
46669 false
46670 true
46671 true

Since unary behaves weirdly no, it doesn't behave weirdly, the unary representation of a non-negative integer n is just n 1s, e.g. 0 = ()₁, 3 = (111)₁, 10 = (1111111111)₁, etc.

@EriktheOutgolfer every position is worth the same in unary, which is a bit weird for a positional notation. But really, I'm just unsure whether including or excluding unary would waste more bytes for the one special case.

Actually the only thing special about it is that it doesn't have the 0 digit, otherwise it works as any other base. However, your challenge is your decision.

@EriktheOutgolfer It does behave quite differently; you can't divide by 1 to n-itshift, for example.

What does consistent integer base mean? (Also, instead of excluding unary in the rules you could just specify N ≥ 2.)

@Lynn A positional notation with a single radix, e.g. base ten, as opposed to a position-dependent radix like you see with imperial units or time.

@Lynn as an addendum, I was also trying to exclude rational, negative, complex etc. bases. As for your second point, the rule about unary is intended to neither include nor exclude unary. Unless my grasp of language lawyering is even feebler than I thought, "undefined behavior" means "whatever the implementing party wants", which is what I was going for.

Sorry but I don't quite follow the discussion about unary. If unary is allowed, then you can hardcode "true" as output because any integer will end in 1 in unary representation.

@CompuChip this is why the "three digit" requirement is also there, which makes 3 the only unary that returns true.

Ah, that's where I misread... thought the input was a three-digit number (in decimal) and the question was whether it ends in one in any base. Makes sense then.

JavaScript (ES7), 43 40 39 bytes
f=(n,b)=>n<b*b?0:n%b==1&n<b**3|f(n,-~b)

Test cases

f=(n,b)=>n<b*b?0:n%b==1&n<b**3|f(n,-~b)

console.log('[Truthy]')
console.log(f(5))
console.log(f(73))
console.log(f(101))
console.log(f(1073))
console.log(f(17))
console.log(f(22))
console.log(f(36))
console.log(f(55))
console.log(f(99))
console.log(f(46656))
console.log(f(46657))
console.log(f(46658))
console.log(f(46659))
console.log(f(46660))
console.log(f(46663))
console.log(f(46665))
console.log(f(46666))
console.log(f(46670))
console.log(f(46671))

console.log('[Falsy]')
console.log(f(8))
console.log(f(18))
console.log(f(23))
console.log(f(27))
console.log(f(98))
console.log(f(90))
console.log(f(88))
console.log(f(72))
console.log(f(68))
console.log(f(46661))
console.log(f(46662))
console.log(f(46664))
console.log(f(46667))
console.log(f(46668))
console.log(f(46669))

Commented
f = (n,           // given n = input
        b) =>     // and using b = base, initially undefined
  n < b * b ?     // if n is less than b²:
    0             //   n has less than 3 digits in base b or above -> failure
  :               // else:
    n % b == 1 &  //   return a truthy value if n is congruent to 1 modulo b
    n < b**3 |    //   and n is less than b³ (i.e. has less than 4 digits in base b)
    f(n, -~b)     //   or the above conditions are true for some greater value of b

Jelly, 7 bytes
bRṫ€3ċJ

Returns the number of bases (non-zero being truthy, zero being falsy) in which the input is a three digit number ending in one.
Try it online!
How it works
bRṫ€3ċJ  Main link. Argument: n

 R       Range; yield [1, ..., n].
b        Base; convert n to bases 1, ..., n.
  ṫ€3    Tail each 3; remove the first two elements of each digit array.
      J  Indices of [n]; yield [1].
     ċ   Count the number of times [1] appears in the result to the left.

Python 3, 50 47 bytes
-2 bytes thanks to @LeakyNun
-1 byte thanks to @Dennis
lambda n:any(i>n/i/i>n%i==1for i in range(2,n))

Try it online!

Haskell, 41 40 bytes
f n=or[mod n k==1|k<-[2..n],k^2<n,n<k^3]

Thanks to @Zgarb for golfing off 1 byte!
Try it online!

Brachylog, 10 bytes
≥ℕ≜;?ḃ₍Ṫt1

Try it online!

8 bytes, although I'm not entirely sure why it works but some close variants don't.

05AB1E, 11 8 bytes
Saved 3 bytes thanks to Adnan.
Lв3ù€θ1å

Try it online!
Explanation
Lв            # convert input to bases [1 ... input]
  ʒg3Q}       # keep only elements of length 3
       €θ     # get the last item of each
         1å   # is there any 1?

Jelly, 12 bytes
bRµL€żṪ€3,1e

Try it online!

Mathematica, 43 bytes
!FreeQ[IntegerDigits[#,2~Range~#],{_,_,1}]&

Try it online!
or Try it online! (large numbers)
Martin Ender saved 3 bytes

!FreeQ[#~IntegerDigits~Range@#,{_,_,1}]& is a bit shorter if you don't mind seeing the IntegerDigits::ibase: Base 1 is not an integer greater than 1. warning. (It still returns the correct answers.)

Clean, 58 56 bytes
-2 thanks to Dennis
import StdEnv
@n=or[n>m^2&&n<m^3&&n rem m==1\\m<-[2..n]]

Try it online!

Wolfram Language (Mathematica), 35 bytes
Or@@Array[x~Mod~#==1<x/#^2<#&,x=#]&

Try it online!
Explicitly checks whether n % i = 1 and i2 < n < i3 for any possible base i. For golfing purposes, the inequality is rearranged to 1 < n/i2 < i, so that it can be chained onto the equality.

Husk, 10 bytes
€;1ṠMo↓2Bḣ

Try it online!
Pretty close to the Jelly answer of Dennis.

APL (Dyalog Unicode), 21 20 14 bytesSBCS
-5 thanks to @ngn.
Purely arithmetic solution (doesn't actually do any base conversions) and thus very fast.
3∊⊢(|×∘⌈⍟)⍨1↓⍳

Try it online!
⊢(…)⍨1↓⍳ on one dropped from the ɩndices 1…argument and the argument, apply:
 | the division remainders
 ×∘⌈ times the rounded-up
 ⍟ logN Argument
3∊ is three a member of that?

you can save 1 with the standard trick of swapping the arguments: ⊢(∨/(3=∘⌈⍟)∧1=|)⍨1↓⍳

@ngn Thanks. Next time, feel free to just edit such (if you feel like it).

ok. Here's a more complex improvement which I leave for you to handle - it makes this as short as your other solution: (⊂1 3)∊⊢(⌈|,¨⍟)⍨1↓⍳

3∊⊢(|×|×∘⌈⍟)⍨1↓⍳

@ngn Why the double |× ?

to avoid matching residue=3 and logarithm=1

@ngn 1=⌈a⍟b, a≤b → a=b → 0=a|b ∵ 0=b|b

excellent :) I didn't think about that

Pyth, 10 bytes
}]1>R2jLQS

Verify all the test cases.

Husk, 15 bytes
V§&o=1→o=3LṠMBḣ

Try it online!
Explanation
V§&(=1→)(=3L)ṠMBḣ  -- implicit input, for example: 5
             ṠMB   -- map "convert 5 to base" over..
                ḣ  --   range [1..5]
                   -- [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]
V                  -- does any of the elements satisfy the following
 §&( 1 )( 2 )      --   apply functions 1,2 and join with & (logical and)
         =3L       --     is length equals to 3?
    =1→            --     is last digit 1?

PHP, 48+1 bytes
while(++$b**2<$n=$argn)$n%$b-1|$n>$b**3||die(1);

exits with 0 for falsy (or input 3), 1 for truthy.
Run as pipe with -nR or try it online.

C, 60 bytes
A function that returns non-zero if the argument can be represented as a three-digit number ending in 1:
i,j;f(n){for(j=0,i=sqrt(n);i>cbrt(n);)j+=n%i--==1;return j;}

Note: this works with GCC, where the functions are built-in.  For other compilers, you probably need to ensure that the argument and return types are known:
#include<math.h>

Explanation
The lowest base in which n is represented in 3 digits is ⌊∛n⌋, and the lowest base in which n is represented in 2 digits is ⌊√n⌋, so we simply test whether the number is congruent to 1 modulo any bases in the 3-digit range.  We return the count of the number of bases satisfying the condition, giving a non-zero (truthy) or zero (falsy) value as appropriate.
Test program
Pass any number of inputs as positional parameters:
#include<stdio.h>
int main(int c,char**v)
{
    while(*++v)
        printf("%s => %d\n", *v, f(atoi(*v)));
}

APL (Dyalog Unicode), 19 bytesSBCS
Dennis' method.
(⊂,1)∊2↓¨⊢⊥⍣¯1¨⍨1↓⍳

Try it online!
(⊂,1)∊ Is [1] a member of
2↓¨ two elements dropped from each of
⊢⊥⍣¯1¨⍨ the argument represented in each of the bases
1↓⍳ one dropped from the ɩndices 1 through the argument?

Julia, 31 bytes
n->any(i>n/i^2>n%i==1for i=2:n)

Try it online!

Pyt, 35 33 bytes
←ĐĐ3=?∧∧:ŕĐ2⇹Ř⇹Ľ⅟⌊⁺3=⇹Đ2⇹Ř%*ž1⇹∈;

Explanation:
←ĐĐ                                             Push input onto stack 3 times
   3=?  :                       ;               If input equals 3, execute code after the question mark;otherwise, execute code after the colon. In either case, afterwards, execute the code after the semicolon
      ∧∧                                        Get 'True'
        :                                       Input not equal to 3
         ŕ                                      Remove 'False'
          Đ2⇹Ř                                  Push [2,3,...,n]
              ⇹Ľ⅟⌊⁺                             Push [floor(log_2(n))+1,floor(log_3(n))+1,...,floor(log_n(n))+1]
                   3=                           Is each element equal to 3
                     ⇹                          Swap the top two elements on the stack (putting n back on top)
                      Đ2⇹Ř                      Push [2,3,...,n]
                          %                     Push [n%2,n%3,...,n%n]
                           *                    Multiply [n%x] by the other array (i.e. is floor(log_x(n))+1=3?)
                            ž                   Remove all zeroes from the array
                             1⇹∈                Is 1 in the array?
                                ;               End conditional
                                                Implicit print

Try it online!

><>, 42 bytes
1<v?)}:{*::+
n~\1-:::**{:}):?!n~:{:}$%1=:?

Try it online!
Returns 10 for truthy, 00 for falsey.


text:
Unicode Fractions
Given a fraction in the format m/n (where m and n are coprime integers), output the corresponding Unicode fraction. Your program/function will not be expected to take in any input that does not correspond to a Unicode character. Arrays, e.g. [2, 3] as opposed to 2/3, are accepted. m / n as opposed to m/n is also fine. Two separate inputs m and n are also valid.
The Unicode fractions that must be handled are as follows:
½, ⅓, ⅔, ¼, ¾, ⅕, ⅖, ⅗, ⅘, ⅙, ⅚, ⅐, ⅛, ⅜, ⅝, ⅞, ⅑, ⅒

Thus, the possible inputs are as follows:
1/2, 1/3, 2/3, 1/4, 3/4, 1/5, 2/5, 3/5, 4/5, 1/6, 5/6, 1/7, 1/8, 3/8, 5/8, 7/8, 1/9, 1/10

The Unicode codepoints of the characters are as follows:
188 ¼
189 ½
190 ¾
8528 ⅐
8529 ⅑
8530 ⅒
8531 ⅓
8532 ⅔
8533 ⅕
8534 ⅖
8535 ⅗
8536 ⅘
8537 ⅙
8538 ⅚
8539 ⅛
8540 ⅜
8541 ⅝
8542 ⅞

Test Cases
1/2 -> ½
1/3 -> ⅓
2/3 -> ⅔
1/4 -> ¼
3/4 -> ¾
3/8 -> ⅜
1/10 -> ⅒

Make your code as short as possible; this is code golf.

Can you add the unicode code points for each fraction?

188 ¼, 189 ½, 190 ¾, 8528 ⅐, 8529 ⅑, 8530 ⅒, 8531 ⅓, 8532 ⅔, 8533 ⅕, 8534 ⅖, 8535 ⅗, 8536 ⅘, 8537 ⅙, 8538 ⅚, 8539 ⅛, 8540 ⅜, 8541 ⅝, 8542 ⅞

You will not be expected to allow any input that does not correspond to a unicode character. Does that mean that we must detect invalid inputs? Or that this is not supposed to happen?

@Arnauld The latter one.

Can the input be an object that represents a fraction?

@BradGilbertb2gills What, something like a list?

Perl 6 has Rational types which have a numerator and denominator.

@BradGilbertb2gills Oh, I understand now; thanks! Yes, those are definitely allowed.

JavaScript (Node.js), 78 77 bytes
Saved 1 byte thanks to @HermanLauenstein
Takes input in currying syntax (m)(n).
m=>n=>'¾⅗  ⅜    ⅞⅘½⅓¼⅕⅙⅐⅛⅑⅒⅚⅔⅝⅖'[(m*9+n)%31]

Try it online!

@user202729 I'm sure I used a similar formula elsewhere. I don't remember for which challenge, though. Now, it might be worth trying to generate the characters with String.fromCharCode(), but I'd expect a similar byte count.

-1 byte

@HermanLauenstein Thanks! (I missed that one because I was initially just looking for the smallest modulo. I had already switched to the XOR method when I started removing trailing empty slots.)

And if you post your answer too soon, it will make people to mostly use your approach...

Perl 6,  48  43 bytes
{chr first *.unival==$^m/$^n,(|^191,|(8528..*))}

Try it
{chr first *.unival==$_,(|^191,|(8528..*))}

Try it
Expanded:
{  # bare block lambda with implicit parameter ｢$_｣
  chr

    first               # find the first value

      *.unival ==       # which has a unicode value that matches
          $_,           # the input fraction (as a Rational)

      (
        |^191,     # ¼(189) ½(188) ¾(190)
        |(8528..*) # all of the rest
      )
}

Note that the search has to be split up so that it doesn't return other Unicode characters that have the same unival. (otherwise it would be (1..*))

Wait, Perl 6 has a built-in for this exact thing?

@EriktheOutgolfer I’m not sure that that’s quite how to look at it, but yes, you can access the code point's numeric value reflected in the 9th column from the Unicode Character Database in the file UnicodeData.txt. For example, U+109BC MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS has the character property nv=11/12. There are some 1500 code points with non-empty numeric values—rather more than this small challenge asks one to solve for. These are whole numbers or rationals.

APL (Dyalog), 88 64 bytes
{⎕UCS(⌊(⍺-1)÷(1+⍵≡8)⌈4×⍵≡6)-(291194049⊤⍨10⌿12)[⍵]-189⌈8539××⍵|4}

Try it online!
-3 thanks to dzaima.
Using ETHproductions's 84-byte approach.
The f← included on TIO isn't counted, since it's put there just to be able to test the function.

JavaScript (ES6), 88 86 84 81 79 bytes
Saved 2 bytes thanks to @Arnauld
m=>n=>String.fromCharCode((4%n?8528:188)|"  130470912"[n]*1.3+~-m/-~"3 1"[n-6])

Not quite as short as the other JS answer, but it was fun to calculate the code-point of each fraction mathematically.
Test snippet

let f =
m=>n=>String.fromCharCode((4%n?8528:188)|"  130470912"[n]*1.3+~-m/-~(n-6?n==8:3))

document.body.innerText = [
  [1,2],
  [1,3], [2,3],
  [1,4], [3,4],
  [1,5], [2,5], [3,5], [4,5],
  [1,6], [5,6],
  [1,7],
  [1,8], [3,8], [5,8], [7,8],
  [1,9],
  [1,10]
].map(([m,n])=>m+"/"+n+": "+f(m)(n)).join('\n')

Old method (82 bytes):
m=>n=>String.fromCharCode((4%n?8539:189)-("0x"+"  08162b0a9"[n])+~-m/-~"3 1"[n-6])

Saved 4 bytes on this one thanks to @Arnauld.

-2 bytes on both versions with -~'3 1'[n-6]

SOGL V0.12, 51 bytes
5*+'æ%'⁵%"∫}ΣS“LI─{"#!“+ζ}¹"¾ŗŗŗŗŗŗ⅛ŗ⅜½⅝ŗ⅞ ⅓⅔ŗ  ¼”W

Try it Here!
uses the mapping (m + n*5)%33%22
Explanation:
5*                        multiply the 1st input by 5
  +                       add to the 2nd input
   'æ%                    modulo 33
      '⁵%                 module 22

"∫}ΣS“                    push 2153527158
      LI─                 base 11 decode that - [10 0 5 6 7 8 9 1 2]
         {     }          for each of that
          "#!“+             add 8528
               ζ            and convert to a character
                "...”     push "¾ŗŗŗŗŗŗ⅛ŗ⅜½⅝ŗ⅞ ⅓⅔ŗ  ¼", replacing ŗ with each character of the above array
                     W    and get the (m + n*5)%33%22th item from that

Clojure, 127 bytes
(comp{2/3\⅔ 4/5\⅘ 1/3\⅓ 1/2\½ 5/6\⅚ 1/5\⅕ 1/4\¼ 3/5\⅗ 1/7\⅐ 3/4\¾ 2/5\⅖ 1/6\⅙ 1/9\⅑ 1/8\⅛ 3/8\⅜ 1/10\⅒ 5/8\⅝ 7/8\⅞}read-string)

An anonymous function that takes input as "1/2", and returns the corresponding character.
A straight mapping from a Clojure Ratio to a fraction character. comp, and the fact that Clojure maps are functions really helped here. I needed to pass the string input through read-string to evaluate it as a ratio type, since that allows me to discard all the bloating quotes in the map. comp let me do that point-free, which was nice. The "full" code would be:
(defn to-unicode-fraction [frac]
  (get {2/3\⅔ 4/5\⅘ 1/3\⅓ 1/2\½ 5/6\⅚ 1/5\⅕ 1/4\¼ 3/5\⅗ 1/7\⅐,
        3/4\¾ 2/5\⅖ 1/6\⅙ 1/9\⅑ 1/8\⅛ 3/8\⅜ 1/10\⅒ 5/8\⅝ 7/8\⅞}
       (read-string frac)))

After looking over the other answers, I realized that this approach is pretty naïve. I'm looking for ways of improving it.

Swift, 106 82 bytes
Port of @Arnaulds JavaScript answer
Saved 24 bytes thanks to @Mr.Xcoder
{Array("¾⅗  ⅜    ⅞⅘½⅓¼⅕⅙⅐⅛⅑⅒⅚⅔⅝⅖")[($0*9+$1)%31]}

Try it online!

Use closures for 82 bytes (you don’t have to include var f= in the byte count)

Charcoal, 77 48 46 bytes
Ｆ§§⪪“YW³⦄Ｅν~vγ@⊖Ｘμ～?Iw⸿Ｍ➙b℅¦⦃”,ＮＮ℅⁺℅ι×⁹⁰∨№βι⁹⁴

Try it online! Link is to verbose version of code. Edit: Saved 29 31 bytes by mapping from ASCII chars to multibyte chars. Explanation:
    “....”                  Compressed string `R,EFcGbIMDO,H J,K  Pd,L,N Q,`
   ⪪      ,                 Split on commas
           Ｎ                First input
  §                         Circularly index
            Ｎ               Second input
 §                          Circularly index
Ｆ                           "Loop over" character (loop variable `i`)
                     №βι    Count of `i`s in lowercase letters
                    ∨   ⁹⁴  Replace zero result with 94
                 ×⁹⁰        Multiply by 90
               ℅ι           Take ordinal of `i`
              ⁺             Sum
             ℅              Convert back to character
                            Implicitly print

Python 3, 97 bytes
lambda m,n:'½ ⅓⅔ ¼_¾ ⅕⅖⅗⅘ ⅙___⅚ ⅐ ⅛_⅜_⅝_⅞ ⅑ ⅒'.split()[n-2][m-1]

This doesn't seem to work, you need [n-2][m-1] instead.

Right, I guess I didn't test it first...

Python 3, 87 bytes
lambda n:'⅛⅑⅜¾⅗⅔⅚⅖⅝⅘⅞⅒½⅓¼⅕⅙⅐'[int(n[::2])%50%36%31%18]

Try it online!
or
lambda n:'⅝⅔⅜⅖__⅞¾⅗⅘_⅒½⅓¼⅕⅙⅐⅛⅑⅚'[int(n[::2])%36%27%22]

Try it online!

Vim Script, 67 bytes
fu!F(m,n)
if a:n==10|norm a⅒
else|exe'norm a'.a:m.a:n
endif
endfu

The function works with Vim's digraphs which are entered after starting them iwth ctrl-k. Apparently, the relevant ctrl-k character after the exe'norm is not rendered in the code block above.

source: Stack Exchange

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

sort: votes


text:
Delete the first periodic digit
We all know that whenever a rational number is written in decimal, the result is either terminating or (eventually) periodic. For example, when 41/42 is written in decimal, the result is
0.9 761904 761904 761904 761904 761904 761904 761904 ...

with an initial sequence of digits 0.9 followed by the sequence 761904 repeated over and over again. (A convenient notation for this is 0.9(761904) where the parentheses surround the block of repeating digits.)
Your goal in this challenge is to take a positive rational number, delete the first digit that's part of the repeating sequence, and return the resulting rational number. For example, if we do this to 41/42, we get
0.9  61904 761904 761904 761904 761904 761904 761904 ...

or 0.9(619047) for short, which is 101/105.
If the rational number has a terminating decimal expansion, like 1/4 = 0.25 does, nothing should happen. You can think of 1/4 either as 0.250000000... or as 0.249999999... but in either case, deleting the first digit of the repeating part leaves the number unchanged.
Details

The input is a positive rational number, either as a pair of positive integers representing the numerator and denominator, or (if your language of choice allows it and you want to) as some sort of rational-number object.
The output is also a rational number, also in either form. If the result is an integer, you may return the integer instead of a rational number.
If taking a pair of numbers as input, you may assume they're relatively prime; if producing a pair of numbers as output, you must make them be relatively prime.
Be careful that you find the first digit that starts a repeating block. For example, one could write 41/42 as 0.97(619047) but that doesn't make 2041/2100 (with the decimal expansion 0.97(190476)) a valid answer.
You may assume that in the input you get, the first periodic digit is after the decimal point, making 120/11 = 10.909090909... invalid input: (its first periodic digit could be considered the 0 in 10). You may do anything you like on such input.
This is code-golf: the shortest solution wins.

Test cases
41/42 => 101/105
101/105 => 193/210
193/210 => 104/105
104/105 => 19/21
1/3 => 1/3
1/4 => 1/4
2017/1 => 2017/1
1/7 => 3/7
1/26 => 11/130
1234/9999 => 2341/9999

Can we return 2017 instead of 2017/1?

Yes, if you're doing the rational number thing. (If you're doing the pair-of-integers thing, then I'm not sure what else you'd return except the pair (2017,1).)

May the input be reducible (not fully simplified)? For example, can 2/4 happen in the input?

If input is 120/11 is the correct answer 111/11 or 210/11?

@user202729 You may assume that the input is a fully simplified rational number.

@kasperd Huh, that's a case I hadn't thought of...  I'd want to say 111/11 except that the most highly upvoted answer at the moment returns 210/11, so I will let you pick to avoid invalidating existing answers.

@MishaLavrov alternatively, you could specify that all inputs will be between 0 and 1. (It should only affect the 2017/1 case)

@JungHwanMin There is an infinite number of rational numbers between 0 and 1 for which the question would also apply. I think the simplest example would be 10/11.

@kasperd The zero (ones place) in 0.(90) isn't significant, so including it in the repeating sequence wouldn't really make sense.

Wolfram Language (Mathematica), 59 bytes
FromDigits@MapAt[RotateLeft@*List@@#&,RealDigits@#,{1,-1}]&

Try it online!
Explanation
RealDigits@#

Find the decimal digits of the input.
MapAt[RotateLeft@*List@@#&, ..., {1,-1}]

If there are repeating digits, RotateLeft them. (List@@# prevents the code from attempting to rotate the last decimal digit if the rational number is terminating).
FromDigits@

Convert to rational.

Very clever indeed!

Jelly, 36 32 31 30 bytes
-1 byte thanks to Erik the Outgolfer!
ọ2,5Ṁ⁵*©×Ɠ÷µ×⁵_Ḟ$+Ḟ,®×³+.Ḟ÷g/$

Try it online!
Should be correct. Floating point imprecision add 3 bytes for +.Ḟ.
Relies on the input being irreducible.

Explanation
This relies on:

Let the numerator be n/d in its simplest form. Then the link ọ2,5Ṁ applied to d will give the number of non-periodic digit after the radix point.

ọ2,5Ṁ⁵*©×Ɠ÷µ×⁵_Ḟ$+Ḟ,®×³+.Ḟ÷g/$     Main link (monad take d as input)

    Ṁ                              Maximum
ọ                                  order of
 2,5                               2 or 5 on d
     ⁵*                            10 power
       ©                           Store value to register ®.
        ×Ɠ                         Multiply by eval(input()) (n)
          ÷                        Divide by first argument (d).
                                   Now the current value is n÷d×®.
           µ                       With that value,
            ×⁵                     Multiply by ⁵ = 10
              _Ḟ$                  subtract floor of self
                 +Ḟ                add floor or value (above)
                                   Given 123.45678, will get 123.5678
                                   (this remove first digit after `.`)
                   ,®              Pair with ®.
                     ×³            Scale
                       +.Ḟ         Round to integer
                          ÷g/$     Simplify fraction

30 bytes

@EriktheOutgolfer Thanks!

Python 2, 237 235 214 bytes
-21 bytes thanks to Mr. Xcoder
from fractions import*
F=Fraction
n,d=input()
i=n/d
n%=d
R=[]
D=[]
while~-(n in R):R+=n,;n*=10;g=n/d;n%=d;D+=g,
x=R.index(n)
r=D[x+1:]+[D[x]]
print i+F(`r`[1::3])/F('9'*len(r))/10**x+F("0."+"".join(map(str,D[:x])))

Try it online!
Input is done as a tuple (numerator, denominator); output is a fractions.Fraction object.
This uses a long-division-style method to get the starting and repeating digits of the answer, then moves the first repeating digit to the end and uses string manipulation and fraction.Fraction to convert it back to a ratio.
Ungolfed version:
import fractions

num, denom = input()
integer_part, num = divmod(num, denom)

remainders = []
digits = []
current_remainder = num
while current_remainder not in remainders:
    remainders.append(current_remainder)
    current_remainder *= 10
    digit, current_remainder = divmod(current_remainder, denom)
    digits.append(digit)

remainder_index = remainders.index(current_remainder)
start_digits = digits[:remainder_index]
repeated_digits = digits[remainder_index:]

repeated_digits.append(repeated_digits.pop(0))

start_digits_str = "".join(map(str, start_digits))
repeated_digits_str = "".join(map(str, repeated_digits))

print(integer_part+int(repeated_digits_str)/fractions.Fraction('9'*(len(repeated_digits_str)))/10**len(start_digits_str)+fractions.Fraction("0."+start_digits_str))

Python 3, 177 173 169 bytes
from fractions import*
def f(n,d):
 i=1;r=[]
 while~-(i%d in r):r+=[i%d];i*=10
 r=10**r.index(i%d);u=i-r;v=i//r-1;t=u//d*n
 return Fraction(t-t%v+t%v*10//v+t%v*10%-~v,u)

Try it online!

@Mr.Xcoder edited

Perl 6, 102 bytes
{$/=.base-repeating;(+$0//$0~0)+([~]([$1.comb].rotate)/(9 x$1.chars)*.1**(($0~~/\.<(.*/).chars)if $1)}

Try it
Takes a Rational number and returns a Rational or Int number.
Expanded:
{  # bare block lambda with implicit Rational parameter ｢$_｣

  $/ = .base-repeating; # store in ｢$/｣ the two strings '0.9' '761904'

    # handle the non-repeating part
    (
      +$0        # turn into a number
      // $0 ~ 0  # if that fails append 0 (handle cases like '0.')
    )

  +

    # handle the repeating part
    (
          [~]( [$1.comb].rotate ) # rotate the repeating part
        /
          ( 9 x $1.chars )        # use a divisor that will result in a repeating number

        *

         # offset it an appropriate amount

         .1 ** (
           ( $0 ~~ / \. <( .* / ).chars # count the characters after '.'
         )

      if $1  # only do the repeating part if there was a repeating part
    )
}

Note will handle denominators upto uint64.Range.max to handle larger denominators use FatRat(9 x$1.chars) Try it.

Wolfram Language (Mathematica), 70 67 bytes
Thanks to this tip (now deleted) for -3 byte!
(x=10^Max@IntegerExponent[#,{2,5}];(Floor@#+Mod[10#,1])/x&[x#2/#])&

Try it online!
A port of my Jelly answer. Longer than the existing Mathematica answer by 8 bytes...
The function take 2 input [denominator, numerator], such that GCD[denominator, numerator] == 1.

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


text:
Count of relatively prime partitions
The partitions of an integer N are all the combinations of integers smaller than or equal to N and higher than 0 which sum up to N.
A relatively prime partition is an integer partition, but whose elements are (overall) coprime; or in other words, there is no integer greater than 1 which divides all of the parts.
Task
Given an integer as input, your task is to output the count of relatively prime partitions it has. Rather not surprised that there is an OEIS sequence for this. The aim is to shorten your code as much as possible, with usual code golf rules.
Also, you don't have to worry about memory errors. Your algorithm must only theoretically work for an arbitrarily big values of N, but it is fine if your language has certain limitations. You can assume that N will always be at least 1.
Test cases and Example
Let's take 5 as an example. Its integer partitions are:
1 1 1 1 1
1 1 1 2
1 1 3
1 2 2
1 4
2 3
5

From this, the first 6 only are relatively prime partitions. Note that the last one (formed by the integer in question only) must not be taken into account as a relatively prime partition (except for N=1) because its GCD is N.
N -> Output

1  -> 1
2  -> 1
3  -> 2
4  -> 3
5  -> 6
6  -> 7
7  -> 14
8  -> 17
9  -> 27
10 -> 34

related.

JavaScript (ES6), 130 120 bytes
f=(n,d=n)=>d&&(n%d?0:(M=n=>n%++k?k>n||M(n):n/k%k&&-M(n/k))(n/d,k=1)*(P=n=>!k|n<0?0:n?P(n,k--)+P(n-++k):1)(k=d))+f(n,d-1)

Demo

f=(n,d=n)=>d&&(n%d?0:(M=n=>n%++k?k>n||M(n):n/k%k&&-M(n/k))(n/d,k=1)*(P=n=>!k|n<0?0:n?P(n,k--)+P(n-++k):1)(k=d))+f(n,d-1)

for(n = 1; n <= 30; n++) {
  console.log('a(' + n + ') = ' + f(n))
}

How?
This is recursively computing:
     /                  \     /                   \
    |  (M = n =>         |   |  (P = n =>          |
    |    n % ++k ?       |   |    !k | n < 0 ?     |
    |      k > n ||      |   |      0              |
    |      M(n)          |   |    :                |
sum |    :               | * |      n ?            | for d in divisors(n)
    |      n / k % k &&  |   |        P(n, k--) +  |
    |      - M(n / k)    |   |        P(n - ++k)   |
    |  )(n / d, k = 1)   |   |      :              |
    |                    |   |        1            |
    |                    |   |  )(k = d)           |
     \                  /     \                   /
        Möbius(n / d)            npartitions(d)

That explanation formatting is slick. Nice.

Pyth, 7 bytes
/iM./Q1

Test suite.
Explanation

/iM./Q1  | Full program.
         |
   ./Q   | The integer partitions (./) of the evaluated input (Q).
 iM      | Get the GCD (i) of each (M).
/     1  | Count (/) the 1's (1).

Pyth's behaviour comes in handy, since mapping with a 2-argument function automatically folds the command on the list, and the GCD of a one-element list is the element itself, so we don't have to handle that separately.

7 second difference and a tie :D

Alternative: s/1iM./

Pari/GP, 39 bytes
This sequence (A000837) is the Möbius transform of the partition numbers (A000041).
n->sumdiv(n,d,moebius(n/d)*numbpart(d))

Try it online!

Wolfram Language (Mathematica), 35 bytes
Count[GCD@@@IntegerPartitions@#,1]&

Try it online!
This is my first Mathematica submission. Thanks to alephalpha for -4 bytes!

Count[GCD@@@IntegerPartitions@#,1]&

@alephalpha Thank you very much! I was trying to use the shorthands to Map or Apply from the tips page but couldn't figure it out.

Jelly, 7 bytes
Œṗg/€ċ1

Try it online!

Swift, 202 185 bytes
Saved 17 bytes thanks to @Mr.Xcoder
func p(_ n:Int,_ m:[Int]=[])->[[Int]]{return 0<n ?(1...min(m.last ?? n,n)).flatMap{p(n-$0,m+[$0])}:[m]}
{n in n>1 ?p(n).filter{a in !(2...n).contains{m in !a.contains{$0%m>0}}}.count:1}

Try it online!
Explanation
func p(_ n:Int,_ m:[Int]=[])->[[Int]]{// Recursive helper function p where p(n, prefix) is
                                      // a list of all possiblie partitions of n
  return n > 0 ?                      // If n > 0:
    (1 ... min(m.last ?? n, n))       //   For i in range from 1 to min(n, last value in prefix):
      .flatMap{p(n - $0, m + [$0])}   //     Add p(n - i, prefix + i) to the return list
  :                                   // Else:
    [m]                               //   Return just the prefix
}
{n in                                 // Main function:
  n > 1 ?                             // If n > 1:
    p(n).filter {a in                 //   Take the list of possible partitions of n where
      !(2...n).contains{m in          //   there is no integer m in the range from 2 to n where
        !a.contains{$0%m>0}           //   all elements in the partitioning divide m
      }
    }.count                           //   and return the length of the list
  :                                   // Else (if n == 1):
    1}                                //   Return 1

Closures are nearly always shorter ~ 185 bytes, no need to include var f= ~ Try it online!


text:
Output the language name times the number of characters
Challenge:
Your task is to use any language to output that language's name times the number of character's in its name.

Use the common name or acronym of the language.
If there are
multiple versions of a language, you need not include the version number.
The capitalization matters.

Examples:
PHP -> PHPPHPPHP
Java -> JavaJavaJavaJava
C++ -> C++C++C++
Python 3 -> PythonPythonPythonPythonPythonPython
JavaScript -> JavaScriptJavaScriptJavaScriptJavaScriptJavaScriptJavaScriptJavaScriptJavaScriptJavaScriptJavaScript

Tasks that depend on a language's name are a form of disadvantaging  some languages by arbitrary criteria.

Oops, sorry, I wasn't aware of that. I will keep this in mind in the future.

As this is essentially outputting a fixed string, albeit different per language, I have tagged this with kolmogorov-complexity.

I think this challenge would have been a lot more interesting if the repetition count was supposed to be our bytecount...

This may be not a great challenge, but IMHO a question that has got 50+ answers deserves more upvotes...

And because it hasn't been said yet: Welcome to PPCG! I hope you stick around despite your probably confusing first impression of people telling you that this is not a good challenge while one answer after the other arrives.

I think you should get bonus score for having the same code run in multiple languages.

@corsiKa that would be interesting but we usually frown upon bonus scores in [tag:code-golf] challenges.

Let’s say I am writing this in Java. What’s stopping me from coding System.out.print(“JavaJavaJavaJava”);?

@DonielF nothing is stopping you from doing that. :)

Then I think this was a fairly poorly thought-out challenge. :/

@DonielF is that shortest though?

@DonielF Hardcoding the output of kolmogorov complexity challenges is always allowed. When that ends up being the shortest method it is not a super interesting challenge but for most of the non-single-byte-name languages it is not the shortest

Would it help to adjust the score as the length divided by the length of the program name? That wouldn't change the score for all the 1-byte language names but would bring others closer to lower scores.

95 answers is a lot to change for scoring

IMO this is unclear. Use the common name suggests that, for example, JS could be used for JavaScript. But what's to stop me saying that my language "Language" is more commonly known as "L"?

@FlipTack There's a difference between "common name" and "made up name". It's easy to verify if a language name is "common". For example, "J" is not a common name for "Java". Additionally, in order for a name to be common, surely it must be used in place of the language name at least in writing or colloquially. IMO, just because it isn't machine verifiable, doesn't make this criterion unclear.

@ConorO'Brien Its not machine verifiable but its also not really human verifiable.  The challenge author doesn't really specify what they mean by common name. If "used in place of the language name at least in writing or colloquially" is the criterion then that ought to be said in the challenge.  And even then I still would feel that there are going to be cases on the edge, is it swipl, SWI-Prolog or just Prolog? Is clisp acceptable instead of common-lisp what about just lisp? Internet searches seem to reveal that these terms are used but they tend not to be used as much as other longer terms.

This is touched on in WheatWizard's comment but how should we deal with language's with different implementations? Should we use the language name or the implementations name? What if our code uses implementation specific features that don't exist in the language?

I think that a good clarification (that could get this reopened) would be something along the lines of The "common name" is defined as the name that is on the language's main webpage/repository. And you should remove common name or acronym, because then JavaScript = JS.

How is this unclear? I don't like the idea of this challenge, but I don't see why it should be put on hold as unclear.

@J843136028 Due to the fact that there's no way to define what the "common name" of a language is.

@MDXF Isn't it obvious what the name of a language is?

@J843136028 Issue is, it's hard to define objectively.

V, 2 bytes
iV

Try it online!
Citing Arnauld, with Levenshtein distance of 1:

I now have 15 seconds of experience in V programming. So, this may actually be golfable.

2 bytes. :P

@totallyhuman It's indeed golfable.

Well, right language for the job! :)

J, 7 bytes
I now have 15 seconds of experience in J programming. So, this may actually be golfable(1).
echo'J'

Try it online!
(1) Edit: And of course it was. Thanks to @ConorO'Brien for  saving 2 bytes! Using a verb:
5 bytes
'J'"_

Your answer became the one with most citations...

@user202729 Is there a hat for that?

You could also make this a verb (function) (5 bytes): 'J'"_. The rank conjunction ", when it has a left-arg as a noun, it makes that noun into a constant verb returning that noun.

Haskell, 16 bytes
h>>h
h="Haskell"

Try it online!
Applied on two lists, (>>) concatenates the second list with itself as often as the first list has elements.

Point-free (19 bytes)
id=<<(>>)$"Haskell"

Try it online!
(id=<<) is the same as join, but without the need for import Control.Monad.

I think you will need to count the putStr as well, or at least the s= that creates the nullary function.

@Bergi It is not needed according to the current Meta consensus on this topic, though I'd also be happy to change my answer if you have a good argument in favour of requiring a leading s=.

Ah, I already understood the "function" in program or function as a function declaration statement, not a function value expression.

4, 11 bytes
3.600525004

Explanation:
3.            Required prefix for all 4 programs.
  6            Set
   00            The cell at index 0
     52          To 52 (ASCII value for '4').
       5       Print
        00      The cell at index 0.
          4   Required suffix for all 4 programs.

Try it online!

I was just going to write that...

Operation Flashpoint scripting language, 64 bytes
f={s="%1%1%1%1";format[s+"%1",format[s,"Operation Flashpoint"]]}

Since there is no official name for the scripting language, I'm using Operation Flashpoint as the name of the language.
Call with:
hint call f

Output:

R, 8 bytes
cat("R")

Try it online!

I think this can be done in 7 bytes, just "R" but called with source(<program name>,ec=T)

With the ec=T being like a compiler flag for +4 bytes

@Giuseppe I think using RGui, RStudio, or anything else with a REPL, you can just do "R". I don't know if that counts.

@KSmarts outputs [1] "R" for me...

@KSmarts meta post

Retina, 12 bytes

Retina
.
$_

Try it online!
Explanation

Retina

Initialise the string to Retina.
.
$_

Replace each character with the full string.

///, 17 bytes
/i/\\\//iiiiiiiii

Try it online!
(this prints /////////)

Naive solution is (only) 1 byte longer.
\/\/\/\/\/\/\/\/\/

Trying to remove the duplicated is actually increases byte count.
/#/iii//i/\\\//###

Verbosity, 458 454 bytes
Include<Integer>
Include<MetaFunctions>
Include<Output>
Include<String>
Integer:DefineVariable<o; 1>
Output:DefineVariable<P; 0>
String:DefineVariable<s; "VerbosityVerbosityVerbosityVerbosityVerbosityVerbosityVerbosityVerbosityVerbosity">
String:DefineVariable<q; String:RemoveCharactersFromStart<s; o>>
String:DefineVariable<r; String:TakeFirstCharacters<q; o>>
Output:DisplayAsText<P; r>
DefineMain<> [
MetaFunctions:ExecuteScript<MetaFunctions@FILE>
]

Try it online!
Saved 4 bytes thanks to NieDzejkob!
You know your language is verbose when it's shorter to create an 81 character long string that it is to multiply a 9 character long string by 9.

454 bytes

@NieDzejkob Nice! That's quite clever!

C, 12 bytes
f(x){x="C";}

Try it online! (GCC)
Saved 3 bytes with help from user202729. C has been chosen strategically, but this is pretty much GCC-specific.

How can this function be used in a program?

@anatolyg See the tio link.

Can't say that's fair considering it requires other code to actually run.

@GalenNare Typically on this site, we allow function submissions. This is just a function.

Lovely way to generate lots of warnings though :)

M, 2 bytes
”M

Single-letter languages have a clear advantage.
Try it online!

Chef, 268 bytes
C.

Ingredients.
102 l f
101 l e
104 l h
67 l c
4 g i

Method.
Put f into the mixing bowl.
Put e into the mixing bowl.
Put h into the mixing bowl.
Put c into the mixing bowl.
V the i.
Pour contents of the mixing bowl into the baking dish.
V the i until ved.

Serves 1.

Try it online!
More idiomatic (565 bytes):
PPCG Holiday Punch.

Ingredients.
408 ml apple cider
404 ml ginger beer
416 ml champagne
67 ml unsweetened cranberry juice
4 pinches mixed spice

Method.
Put apple cider into the mixing bowl.
Divide mixed spice into the mixing bowl.
Put ginger beer into the mixing bowl.
Divide mixed spice into the mixing bowl.
Put champagne into the mixing bowl.
Divide mixed spice into the mixing bowl.
Put unsweetened cranberry juice into the mixing bowl.
Sift the mixed spice.
Pour contents of the mixing bowl into the baking dish.
Sift the mixed spice until sifted.

Serves 5.

Try it online!

Now that is a neat language.

ArnoldC, 107 bytes
IT'S SHOWTIME
TALK TO THE HAND "ArnoldCArnoldCArnoldCArnoldCArnoldCArnoldCArnoldC"
YOU HAVE BEEN TERMINATED

Try it online!

Whispers, 36 bytes
> "Whispers"
> 8
>> 1×2
>> Output 3

Try it online!
Trivial question, trivial answers.

A tiny bit more interesting, but same bytecount: https://tio.run/##K8/ILC5ILSr@/99OQSkcylHisrNTcE1MzlAwVDAEsf1LSwpKSxSM/v8HAA

><>,  23 19 15 13  12 bytes
"><>" |o<.0l

Try it online!
Emigna saved 4 bytes. Not a tree saved another 3. Teal pelican managed to save 1 more byte. Thanks to all who have helped golfing! Citing Arnauld, with slight modifications: I now have 15 seconds of experience in ><> programming. So, this may actually be golfable.

"><>><>><>"oa0.

13 bytes: "><>"|o<"><>"

After having a play around using both Emigna and Notatree's changes and mixing both you can reduce this a further 1 byte:    "><>" |o<.0l

@Tealpelican: That is ingenious!

@Tealpelican Thank you!

Could you provide an explanation?

@FlipTack Not sure I completely understand my code, but: "><>"  enables string parsing and pushes ><> to the stack, | mirrors (the IP will change direction depending on what direction it already has), o outputs as a character (string, in this case), < changes the direction of the instruction to the left, . pops the last two elements off the stack and moves the IP to the point which has the two as coordinates, 0 just pushes a 0 and l pushes the length of the stack onto the stack. If you dunno what I mean by "IP" and "direction", please see this.

@Mr.Xcoder I understand 2D languages, I just wasn't aware of the specific command .

,,,, 6 bytes
',9i×

Try it online!
Hehe...

7, 3 bytes
31317403

Try it online!
Format similar to Hello World program, except output mode is 3 (Byte-per-three-commands). The three commands 131 encodes value 131 base 6 = 37 base 16 = character 7. Then 3 prints the character.

Python 3, 17 bytes
print("Python"*6)

Try it online!
Of course, Python 2 is 2 bytes shorter with
print"Python"*6

Try it online!
But I prefer Python 3

You know you could have used Python 2...

@Mr.Xcoder Edited in, but I prefer Python 3

Everybody does, but Python 2 is almost always golfier. :P

@totallyhuman s/almost/almost\{when manipulating sets and lists}/ :P

@Mr.Xcoder You missed a terminating /?

Wouldn't 'Python'*6 work too?

@GalenNare No. The result has to be printed/returned, which that doesn't.

Starry, 146 bytes
        + +*`        + +  * +  *       +* .                + +  * +          + * + .       + * +          + +* +  *        + * . . . .      + * +'

Try it online!
It looks prettier with decoration, though (180 bytes):
        + +*`
+ + /| * +  *       +
* .| \__
  + \__/+  * +__
     + * + . /  \
+ * +      ========
  + +* +  *  \__/
  + * . . . .      +
* +'

Try it online!

Commentator, 316 bytes
           {-     {-    -}!  {-{- e#-}//{-#-}-}! {-
;{-
     {-   -}!!  -}////{-#{-#-}    {-     -}!-}//-}//e#   e#-}//     -}//-}//{-e#                   e#-}-}//e#      e#-}//-}//-}//-}//e#         e#{-e# e#{-e# e#{-e#         e#-}-}-}-}-}
;{-/*{-/*{-/*{-/*{-/*{-/*{-/*{-/*{-/*{-/*{-/*-}-}-}-}-}-}-}-}-}-}-}

Try it online!
Not quite as long as my Verbosity answer, but getting there

MSM, 9 bytes
..;;..MSM

Stack trace:
. . ; ; . . M S M             -- concat
  . ; ; . . M MS              -- concat
    ; ; . . MSM               -- dup
      ; . . MSM MSM           -- dup
        . . MSM MSM MSM       -- concat
          . MSM MSMMSM        -- concat
            MSMMSMMSM

D, 20 bytes
auto f(){return"D";}

Try it online!

One letter language names for the win.

I, 3 bytes
"I"

Try it online!

Haha I got ninja'd

Emoji, 33 bytes
Emoji6➡

Abuses the type system. A lot. May not work on other interpreters than the Python one. It probably won't.
Try it online!

Aceto, 16 bytes
o"pp
tkpp
ecp
"A

Try it online!

Funky, 16 bytes
print("Funky"*5)

Try it online!

05AB1E, 9 bytes
•äƵí•h6×R

Try it online!

0xE1BA50, encoded in base 255, decoded into hexadecimal, repeated 6 times, reversed.

K, 9 bytes
\echo "K"

Try it online!

uBASIC, 27 bytes
1FORI=1TO6:?"uBASIC";:NEXTI

This answer is pretty small, thanks to uBASIC's tokenizer being powered with a solution of magic in unicorn blood.
Try it online!

sed, 10 bytes
isedsedsed

I hope two trailing newlines are OK :P
Try it online!

itflabtijtslwi, 31 bytes
/I/itflabtijtslwi//J/IIIIIII/JJ

Try it online!

Bubblegum, 14 13 bytes
Saved 1 byte thanks to @ovs
00000000: 732a 4d4a ca49 4d2f cda5 1603 00         s*MJ.IM/.....

Try it online!

13 bytes, generated with zopfli.

@ovs Thanks! I was pretty sure I was doing it wrong.

Hexadecimal Stacking Pseudo-Assembly Language, 636 bytes
20002D4077FF00AAAA20006540000020006740000020006140000020007540000020006740000020006e40000020006140000020004c40000020002040000020007940000020006c40000020006240000020006d40000020006540000020007340000020007340000020004140000020002d40000020006f40000020006440000020007540000020006540000020007340000020005040000020002040000020006740000020006e40000020006940000020006b40000020006340000020006140000020007440000020005340000020002040000020006c40000020006140000020006d4000002000694000002000634000002000654000002000644000002000614000002000784000002000654000002000484000001400004277FF4099FF2000014077FF4299FF4077FF2277FF4277FF4077FF0377FF04000101AAAA

Try it online!
Formatted:
20002D4077FF00AAAA200065400000200067400000200061400000200075
40000020006740000020006e40000020006140000020004c400000200020
40000020007940000020006c40000020006240000020006d400000200065
40000020007340000020007340000020004140000020002d40000020006f
400000200064400000200075400000200065400000200073400000200050
40000020002040000020006740000020006e40000020006940000020006b
400000200063400000200061400000200074400000200053400000200020
40000020006c40000020006140000020006d400000200069400000200063
400000200065400000200064400000200061400000200078400000200065
4000002000484000001400004277FF4099FF2000014077FF4299FF4077FF
2277FF4277FF4077FF0377FF04000101AAAA

Explanation
; initialize 77 with 0x002D (45)
20 002D
40 77 (FF)

; label AAAA
00 AAAA

; print out the text
20006540000020006740000020006140000020007540000020006740000020006e40000020006140000020004c400000200020400000
20007940000020006c40000020006240000020006d40000020006540000020007340000020007340000020004140000020002d400000
20006f40000020006440000020007540000020006540000020007340000020005040000020002040000020006740000020006e400000
20006940000020006b40000020006340000020006140000020007440000020005340000020002040000020006c400000200061400000
20006d400000200069400000200063400000200065400000200064400000200061400000200078400000200065400000200048400000
140000

; decrement
    ; move counter to stack 99
        42 77 (FF)
        40 99 (FF)
    ; push 1 to 77
        20 0001
        40 77 (FF)
    ; move counter to stack 77
        42 99 (FF)
        40 77 (FF)
    ; subtract
        22 77 (FF)

; duplicate
42 77 (FF)
40 77 (FF)

; terminate if counter is 0
03 77 (FF)
04 (0001)

; redo
01 AAAA

Standard ML (MLton), 55 54 46 bytes
val s="Standard ML";s^s^s;print(it^it^it^s^s);

Try it online!
Output:
Standard MLStandard MLStandard MLStandard MLStandard MLStandard MLStandard MLStandard MLStandard MLStandard MLStandard ML

Previous version: (55 bytes)
"Standard ML";print(concat(map(fn _=>it)(explode it)));

Try it online! (No worries, the code is harmless, eventhough it contains explode it.)
Explanation:
"Standard ML"; binds the string to the implicit value identifier it. We then explode it to convert the string into a list of characters and map a function fn _=>it over the list which replaces each character with the string. concat combines the list of strings to a single string and print outputs the resulting string.

Hodor, 38 bytes
hodor.hod("HodorHodorHodorHodorHodor")

It's actually shorter than the pure Javascript equivalent!
Try it online!

Japt, 8 7 bytes
4ç"Japt

Try it

;#*, 420 bytes
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Try it online! (uses ;#+ instead)

You can golf this approach.

@ConorO'Brien Well I intended this to be a ;# answer but since that is not considered a language (it cannot perform a primality test), I used ;#+. Will look at the docs and see what I can do

This is a kolgomorov complexity challenge, so primality testing isn't required. This can be a ;# answer if you still want to

@cairdcoinheringaahing Changed to ;#*

Java 11, 19 bytes
v->"Java".repeat(4)

Try it online.
Java 8, 21 bytes
v->"JavaJavaJavaJava"

Well...
Try it here.

JAVA! JAVA! JAVA! JAVA!

brainfuck, 125 119 bytes
+++++++++[>+++++++++++[>+++++++++[>+>+<<-]>>+<<<-]>>-.>++++.<-.++++++++.>----.<---.>+++++++.<---.++++++++.>[-]<[-]<<<-]

First BF, I think it's still golfable but it may be a bit BF to golf BF ;)
Explanation:
+++++++++                        (_009  000  000  000  000)
[
 >+++++++++++                    ( 009 _011  000  000  000)
 [
  >+++++++++                     ( 009  011 _009  000  000)
  [
   >+>+<<-                       ( 009  011 _008  001  001)
  ]                              ( 009  011 _000  009  009)
  >>+<<<-                        ( 009 _010  000  009  010)
 ]                               ( 009 _000  000  099  110)
 >>-.                            ( 009  000  000 _098  110) Output: b
 >++++.                          ( 009  000  000  098  114) Output: r
 <-.                             ( 009  000  000 _097  114) Output: a
 ++++++++.                       ( 009  000  000 _105  114) Output: i
 >----.                          ( 009  000  000  105 _110) Output: n
 <---.                           ( 009  000  000 _102  110) Output: f
 >+++++++.                       ( 009  000  000  102 _117) Output: u
 <---.                           ( 009  000  000 _099  117) Output: c
 ++++++++.                       ( 009  000  000 _107  117) Output: k
 >[-]<[-]<<<-                    (_008  000  000  000  000)
]                                (_000  000  000  000  000)

-6 for removing redundant clear commands
Try it online!

Sinclair ZX81/Timex TS1000/1500 BASIC, ~33 tokenized BASIC bytes for the listing
 LET A$="BASIC"
 1 FOR I=SGN PI TO LEN A$
 2 PRINT A$;
 3 NEXT I

Enter the language name into the var stack using direct mode to save one BASIC line, and save bytes in the listing itself. I assume the A$ variable is five bytes for the string and two bytes for the pointer, but I'm not 100% sure how the this works on the ZX81 - I will find out and update the byte count.
Sinclair ZX81/Timex TS1000/1500 BASIC (non-dynamic solution) ~21 tokenized BASIC bytes (symbolic listing)
 LET A$="BASIC"
 1 PRINT A$;A$;A$;A$;A$

Using the same technique as above, entering the A$ variable in direct mode and then simply printing the string five times. To run either solution, don't use the command RUN or the var stack is initialised. Use:
 GOTO 1

Save 5 bytes by using SGN PI instead of 1. And by my count the second one is only 36 bytes.

Yes, I will optimise futher; also one could use INPUT A$ in line one, and will therefore work with any language inputted into the A$ string

@Neil - how are you counting 36 bytes in the second listing?

The first line is 4 bytes for the line number and length, 1 for the token, 10 normal bytes, 1 for the newline. The second is similar, except it has 14 normal bytes. I make that 36 bytes in total.

It's a good job I put a ~ in front of my byte count isn't it. Somehow I mis-counted. Twice. But I'd rather work out proper byte counts on 8 bit machines, i.e., how much actual memories do my listings take?

Hi MD XF - the Sinclair ZX81 is just that - I've never seen it referred to as a ZX-81.

PHP (9 bytes)
PHPPHPPHP

Try it online

Hah. can't believe str_repeat(3,'PHP') is the long alternative.

Excuse my brevity with this answer; it's hardly a difficult challenge and by the questions posed above, it's apparently a perfectly legal one as well.

TI-BASIC, 16 bytes
"TI-BASIC
Disp Ans,Ans
Ans

Alternatively (19 bytes):
For(I,1,3
Disp "TI-BASIC
End

Befunge-93, 27 Bytes
Edit: Much cleaner solution of the same length suggested by James Holderness
0"39-egnufeB">:#,_$1+:9`#@_

Try It Online
Old 30 byte version:
?
_g7-00p"39-egnufeB">:#,_g`#@

Try It Online
It feels weird to use the ? command for something that isn’t random, but that’s the only direction changing instruction that had an ASCII value low enough

Surely it's easier to just keep the counter on the stack: Try it online!

@JamesHolderness Not if you're printing the "-93" as well. Then it's the same length (but still a much cleaner solution)

Bash, 14 bytes
echo bash{,,,}

Try it online!
ksh, 12 bytes
echo ksh{,,}

Try it online!
sh, 10 bytes
echo sh{,}

Try it online!
Although, for 9 bytes, I can just do echo shsh.

Underload, 28 bytes
(Underload)::::::::********S

Try it online!

(Underload)::**::**S for 20 bytes.

PHP, 27 21 20 bytes
First PHP solution; thanks to everyone who helped out with this. Obviously, I'm not quite ready to start golfing in PHP yet!
<?=str_pad(P,9,HPP);

Try it online
(Yes, <?="PHPPHPPHP"; or just PHPPHPPHP are shorter but they felt far too trivial.)

Thanks to Dennis for some tips on PHP, which also saved a byte.
Thanks to NieDzejkob for saving a further 5 bytes.
Thanks to Titus for saving me a byte and teaching me something new abut PHP.

This looks longer than just using "PHPPHPPHP" to me.

@MartinEnder: yeah, but that just felt far too trivial!

A trailing semicolon is mandatory in PHP. As a full program <?=str_pad($s="PHP",9,$s); would do. Of course, PHPPHPPHP is a neat 9 byte solution.

@Dennis, to the best of my knowledge, a trailing semi-colon isn't required on the last line of a file. Thanks for the tips on the full programme; I'll update shortly.

It can be omitted in certain situations, but the closing ?> is already longer.

@Dennis, ah, yes, I see that now.

<?=str_pad("",9,PHP); for 21 bytes.

Or getting closer to the trivial solution for 18 bytes: <?=($a=PHP).$a.$a;

Oops, fell asleep on the couch yesterday and forgot about this! Thanks for the help, everyone; clearly I'm not ready for golfing in PHP yet! :D

20 bytes: <?=str_pad(P,9,HPP);

Can you explain, @Titus? How come the P & HPP don't need to be quoted?

@Shaggy you don't need to quote strings in PHP as long as you ignore the errors (if there isn't any space or special chars such as - or $ in your string). It's actually one of the top PHP golfing tips

@Shaggy and with -n (which we get for free: no config file), notices such as undefined constant, assuming string are ignored.

APL,  10 7 bytes
∊(⍴c)⍴⊂c←⎕

APL => APLAPLAPL

previous answer above prompted for screen input but if no input is required then we have the trivial for 7 bytes
9⍴'APL'

C++,  24  22 bytes
Thanks to @Quentin for saving two bytes!
[]{return"C++C++C++";}

Try it online!

You can drop the parentheses :)

Husk, 8 6 bytes
‼D¨Ż%k

-2 bytes thanks to @Zgarb!
Try it online or alternatively DD¨Ż%k would work too..
Explanation
‼D¨Ż%k
  ¨Ż%k  -- compressed string: "Husk"
‼D      -- duplicate twice: "HuskHuskHuskHusk"

‼D works too.

SNOBOL4 (CSNOBOL4), 30 bytes
 OUTPUT =DUPL('SNOBOL4',7)
END

Try it online!

Deorst, 11 bytes
'Deorst'l6*

Try it online!

PHP, 59 bytes
Not the best way to do it (and there's a better php solution), but here's my go at it:
<?php $s="php";$l=strlen($s);for($i=0;$i<$l;$i++){echo $s;}

Try it online!

rk, 22 bytes
rk:start
print: "rkrk"

Try it online!

Wait someone else knows about this language :o

Octave, 26 bytes
disp(repmat('Octave',1,6))

Try it online!

MY-BASIC, 33 bytes
for x=1 to 8
print"MY-BASIC"
next

Try it online!

05AB1E, 10 bytes
"05AB1E"6×

Try it online!

Befunge-98 (FBBI), 22 bytes
7v
"<_@#:-1,k6"Befunge

Try it online!
with -98 included:
av
"<_@#:-1,k9"Befunge-98

Try it online!

-2 bytes if you increment instead of decrementing (idea from james holderness' comment on my Befunge-93 answer)

pl, 4 bytes
plpl

Try it online!

Cy, 12 bytes
"CyCy" print

Try it online!

Clojure, 49 37 bytes
12 bytes saved thanks to @cliffroot
(print(apply str(repeat 7"Clojure")))

Try it online!

you can use apply str instead of clojure.string/join ?

@cliffroot nice trick. thanks!

Perl 6,  14  12 bytes
say 'Perl6'x 5

Try it
{'Perl6'x 5}

Try it (bare block lambda that returns a string)
Note that I have it output Perl6 as Perl 5 and Perl 6 are at least as different as C++ and Java are.

try this {'Perl'x 5} to shave off 3 bytes :) Lambda returns are generally accepted as output. Also the question specifically says that different versions of a language, dosent matter. And since it is code golf, i wouldve used that in my favor ;)

@HåvardNygård As I stated Perl 5 and Perl 6 are different languages; they are significantly more different than C and C++, and the C++ answer outputs C++C++C++. At least Perl 5 attempts to maintain backwards compatibility with the original Perl from 1987. I have written an example file that combines both Perl 5 and Perl 6, and the code that I have written to make them compatible is larger than the common code. The language is Perl 6, the family of languages is Perl.

Well, could still return it from the lambda though

Tcl, 14 bytes
puts TclTclTcl

Try it online!

Charcoal, 10 bytes
×Charcoal⁸

Try it online! Alternatively, also 10 bytes:
×⁸Charcoal
Ｆ⁸Charcoal

More idiomatic for 13 bytes would be to say:
≔Charcoalθ⭆θθ
≔CharcoalθＦθθ

Clean, 29 bytes
c="CleanCleanCleanCleanClean"

Because actually doing anything requires import StdEnv, it's shorter to just hardcode.
Try it online!

JavaScript ES7, 30/41/43/33 bytes
Thanks @Shaggy for reducing the size of the second and 4th versions
Boring repeat 10 times: 30 bytes

alert("JavaScript".repeat(10))

Array mapping of a string: 41 bytes

alert([...x="JavaScript"].fill(x).join``)

For loop: 43 bytes

for(i=j='';10>j++;i+="JavaScript");alert(i)

Joining empty 11 element array: 33 bytes

alert(Array(11).join`JavaScript`)

From the spec "Use the common name or acronym of the language." - JS is a common acronym for JavaScript ;)

Also, your last solution can be 33 bytes: alert(Array(11).join'JavaScript'), replacing single quotes with backticks.

And your second can be 41 bytes: alert([...x="JavaScript"].fill(x).join'').

ReRegex, 17 bytes
a/ReRegex/aaaaaaa

Potentially one of the most simple ReRegex answers I've ever written.
Try it online!

Jelly, 7 bytes
“¢³ƒ»ẋ5

Try it online!

Add++, 11 bytes
L,"Add++"5*

Try it online!

Pyth, 7 bytes
*4"Pyth

My first Pyth answer!
Thanks to Mr. Xcoder for a neat trick.
Try it online!

*4"Pyth for 7 bytes

@Mr.Xcoder, neat!

C, 20 bytes
main(){printf("C");}

Try it online!

You can save a few bytes by using puts instead

And even more by making it a function, f(){puts("C");}

This=That, 57 bytes
a=This=That
i=0
while loop j=<9
a=print
while loop j=end

This does exactly what you think it does. The string stored to a is printed nine times, accomplished by the loop.
The idea I get from the Esolangs page is that that equals sign in the first line is part of the string literal, not an assignment operator.
Thanks to @FrownyFrog for pointing out an error.

Bean, 15 bytes
xxd-style hexdump:
00000000: 53d0 80a3 8100 2080 b525 3dc2 e5e1 6e    SÐ.£.. .µ%=Âåán

JavaScript equivalent:
'Bean'.repeat(4)

Try it online!

Ruby, 12 bytes
$><<"Ruby"*4

Because Kaiser Chiefs.
Try it online!

T-SQL, 76 67 bytes
declare @i char(5)='T-SQL',@ int=1 a:print @i set @+=1if(@<6)goto a

You can save up to 11 bytes by using @i+=1 instead of @i=@i+1, change the condition to @i<6, swapping the variable names and replacing the WHILE with a GOTO and IF.

Decimal, 52 bytes
13068101099105109097108D117D91D00D30101D111D42D591D5

Try it online!
Ungolfed / explanation:
13068101099105109097108D 117D   ; push "Decimal", push 17
91D                             ; create jump point 1
  00D 301 01D                   ; set DSI to 0 ("Bitwise"), print, set back to 1 (initially 7)
  111D 42D                      ; push 1, subtract from previous SI
5 91D 5                         ; if DSI truthy, jump to point 1

Fun fact that I just remembered: Decimal doesn't care about the "top of stack" like most stack-based esolangs; it instead operates on a "default stack index" that can be modified at will, allowing for rather easy stack manipulation.

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

Try it online!
This is 228 bytes of code, and +1 for the -A flag.

Scala 27 16 bytes
print("Scala"*5)

I don't know Scala, but would assigning it to a variable be shorter than writing it twice?

or just using 5 instead of "Scala".size

Assigning to a variable takes 29 bytes unfortunately. And yes @Giuseppe I'm dumb....

Ruby, 10 bytes
p "ruby"*4

Try it online!

p"ruby"*4 - you don't need the space.

JavaScript 58 54 bytes
a='',f=i=>i<9?(f(i+1),a+="JavaScript"):0;f(0);alert(a)

Solution using document.write (57 53 bytes)
(f=i=>{i<9?f(i+1):0;document.write("JavaScript")})(0)

Welcome to Programming Puzzles & Code Golf! Please edit your existing answers instead of posting new ones.

Excel VBA, 22 Byte
Anonymous VBE immediate window function that takes no input and outputs to the VBE immediate window
?[Rept("Excel VBA",9)]

Swift, 30 bytes
for _ in 1...5{print("Swift")}

Try it online!

Bitwise, 188 bytes
.SUB:
LABEL &1
NOT $1 *1
AND *1 $2 *2
XOR $1 $2 $1
SL *2 &1 $2
JMP @1 $2
RET $1
MOV 1 &7 &1
OUT &66 1
OUT &105 1
OUT &116 1
OUT &119 1
OUT &105 1
OUT &115 1
OUT &101 1
SUB 1 &1 1
JMP &-9 1

Try it online!
I can't golf the .SUB help D:

C# Interactive, 44 bytes
for(int i=15;--i>0;)Write("C# Interactive");

Haven't found an online compiler, I did it with the C# Interactive REPL in VS 2017.

Implicit, 16 14 12 bytes
Implicit":+7

Try it online!
Implicit       push character codes for I, m, p, l, i, c, i, t
        "      stringify stack
         :     duplicate top of stack
          +7   concatenate top of stack to previous 7 times
               implicit string output

Excel Formula, 24
=REPT("ExcelFormula",12)

shortC, 24 bytes
Da"shortC"
AJa a a a a a

Try it online!
Da"shortC"     // define variable a as string "shortC"
A              // main function
 J             // print string
  a a a a a a  // a, 6 times, auto-concatenated

Julia, 24 15 bytes
Minus 9 bytes thanks to SalchiPapa
print("Julia"^5)

Try it online!

print("Julia"^5)

Ruby: 10 chars
p 'ruby'*4

Result
rubyrubyrubyruby

Previous Implementation: 25 chars
def x(y);p y*y.length;end

Simple invocation:
x('javascript')
 => "javascriptjavascriptjavascriptjavascriptjavascriptjavascriptjavascriptjavascriptjavascriptjavascript"

Powershell, 15 bytes
"Powershell"*10

Very boring. But I can't think of any way to shorten it.

Tomato, 14 bytes
"Tomato"YYYYYY

Eukleides, 37 bytes
e="Eukleides"
print e,e,e,e,e,e,e,e,e

Don't think it can be golfed down any further. While a list of strings can be printed, they can't be assigned to a variable without a cat operation. So, building a string of three "Eukleides"es and printing three of those blows up to 38 bytes:
e="Eukleides"
f=cat(e,e,e)
print f,f,f

Eukleides prints a newline after every print command. If the challenge allowed for newlines between instances of the language name then we could do this in 33 bytes:
for i=1to 9
print "Eukleides"
end

VBA, 11 Bytes
Anonymous VBE immediate window function that takes no input and outputs to the VBE immediate window
?"VBAVBAVBA

LOLCODE, 75 bytes
HAI 1.3
VISIBLE "LOLCODELOLCODELOLCODELOLCODELOLCODELOLCODELOLCODE"
KTHXBYE

Try it online!

Pushy, 11 bytes
`Pushy\x5`:N"

Where \x5 represents the literal byte 0x05.
Try it online!
`Pushy\x5`      \ Push the character codes for 'Pushy', and a 5
          :     \ Pop the 5 and loop 5 times:
           N"   \ Output the rest of the stack, with no newline.

Ruby, 12 bytes
$><<"Ruby"*4

https://codegolf.stackexchange.com/a/151022/66104 ?

Bash, 83 bytes
For the whole version string:
while read -n1;do echo -n `bash --version|head -1`;done< <(bash --version|head -1)

Returns (on my machine):
GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)GNU bash, version 4.4.7(1)-release (x86_64-pc-linux-gnu)

Use the common name or acronym of the language. and If there are multiple versions of a language, you need not include the version number. and for just plain bash I don't think it can get any shorter (although I may be wrong.)

@MDXF You're right, I didn't read the challenge properly.

Excel, 15 Bytes
Anonymous worksheet function that takes no input and outputs to the calling cell
=REPT("Excel",5

This may be ported to Google Sheets for 24 Bytes
=REPT("Google Sheets",13

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


text:
Is it a pleasing number?
A pleasing number (according to this definition) is a number that can be passed through the following process (let's use 41802000 as an example):

Separate the trailing identical numbers (41802000 => [41802, 000])
Sort the first half of the digits and take the maximum ([41802, 000] => [8, 000])
Take the length of the final element. Call the resultant elements A and B ([8, 000] => A=8, B=3)
Is NB = A for any integer N? (True in this example; 23 = 8)

If the input results in True from the following process, it is considered pleasing.
Your task is to take an integer x, and output whether x is a pleasing number. You can output any two distinct values for truthy and falsey, but please state what you're using in your answer. x is guaranteed to have at least two distinct digits (e.g. 111 is an invalid input). As with most challenges, you may take x as a string, or a list of digits.
This is a code-golf so shortest code in bytes wins.
Test cases
          Input          Output
       41802000               1
            100               1
      123456788               0
      451111111               0
234543454545444               0
             12               1
       41902000               0
          92599               1

can the number be passed as a string? (especially given the '234543454545444' test case)

@Uriel You may take input as a string

As a suggestion for clarification: I would use the term "digit" rather than "number", as you are specifically referring to the decimal characters, abstracted from their number values.

list of digits - would this be a list of the ASCII numeral characters, or a list of integers from 0-9

@Οurous Up to you

Would 1 be considered a pleasing number? (01) 0 is 0^1.

@fəˈnɛtɪk - does not matter since "x is guaranteed to have at least two distinct digits" (although I see your "01" reasoning)

@DLosc Added, Thanks!

APL (Dyalog), 36 bytes
{(⊢≡⌊)(⌈/⍎¨⍵/⍨~o)*÷≢⍵/⍨o←⌽⌊\1,2=/⌽⍵}

Try it online!
How?
Almost a poem.
⌽⍵ - reverse the input once,
1,2=/ - get the differences list.
⌊\ - keep only the first group of ones,
⌽ - and flip it over to complete.

o← - assign to o,
~o - switch ones and zero(s),
⍵/⍨ - filter the input with it,
⍎¨ - turn the result into list of each digit,

⌈/ - and get the maximum. (that's A)

⍵/⍨o - filter the input with o unalt(ered),
≢ - and take the length, that would be B.
÷ - get one divided by this result,
* - and take A to that power thee.

⊢≡⌊ - integer?

05AB1E, 11 bytes
γRćgUZXzm.ï

Try it online!
Explanation

γRćgUZXzm.ï ~ Full program.

γ           ~ Split into runs of digits.
 R          ~ Reverse.
  ć         ~ Push a[1:], a[0] to the stack.
   g        ~ Length (of a[0]).
    U       ~ Assign this to the integer variable X.
     ZX     ~ Get the maximum, without popping, and push X.
       zm   ~ A1/B.
         .ï ~ Is it an integer?

Emigna saved 1 byte.
Relies on the fact that if A is a positive integer N raised to the power of B, then N=A1/B, hence it  must be an integer.

UZX should work instead of s{θs

The 9-byte program fails for 41902000 (should be falsy).

@Zgarb Yeah I was nearly sure it would fail, so I removed it... Also lol we got the exact same integer

Fails for 418802000

Haskell, 85 75 72 71 bytes
Edit: -10 bytes by taking a list of digits instead of a string. Thanks to WhatToDo for pointing out that this is allowed. -3 bytes thanks to Ourous' solution in Clean. -1 byte thanks to user28667.
f s|(b,a)<-span(==last s)$reverse s=or[n^length b==maximum a|n<-[1..9]]

Try it online! Takes input as a list of digits. Example usage: f [4,1,8,0,2,0,0,0] yields True.
Explanation:
Given an input s=[4,1,8,0,2,0,0,0], we reverse the list and separate the leading elements with span(==last s): ([0,0,0],[2,0,8,1,4]).
The pattern matching on (b,a) yields b=[0,0,0] and a=[2,0,8,1,4].
The list comprehension or[n^length b==maximum a|n<-[1..a]] checks whether any integer n in the range from 1 to 9 satisfies n^length b==maximum a, that is n^3=8.

You posted yours before I did mine, and ours are similar, so: Try it online!

@WhatToDo Thanks, I didn't see that lists of digits where allowed as input.

Can’t you just take the maximum. No need to check them all.

@Tim I'm not sure I understand what you mean. Taking the maximum of the whole input list to get a would fail in cases like 477.

@Tim I do take the maximum to get b, but check every integer n from 0 to 9 (formerly from 0 to a). That's exactly the specification as far as I see.

I think you can replace (reverse s) with $reverse s

@user28667 Thanks, the parenthesis where needed the previous 75 byte version, but now they indeed can be replaced.

Haskell, 104 89 bytes
@Laikoni found a shorter solution, but this is the best I could do. Thanks @Laikoni for letting me know that we can also accept lists of digits as input.
import Data.List
(g.length.last<*>maximum.concat.init).group
g b a=any(==a)$(^b)<$>[1..a]

Explanation:

Try it online!

Why use any(==a) when you could use elem a?

@WheatWizard Thanks for the suggestions, regarding your second comment: Wouldn' this fail for e.g. 2888?

Yes it seems I misread the question.  I didn't realize that the trailing numbers could be anything other than zero.

but head.maximum is still shorter than maximum.concat by 2 bytes, and maintains the functionality.

Jelly, 11 bytes
ŒgµṪL9*€fṀL

Takes input as a list of digits.
Try it online!
How it works
ŒgµṪL9*€fṀL  Main link. Argument: D (digit array)

Œg           Group runs of digits, yielding a run array R.
  µ          Begin a new chain with argument D.
   Ṫ         Tail; remove and yield the last element of D.
    L        Take the length. Let's call it b.
     9*€     Compute [1**b, ..., 9**b].
         Ṁ   Take the maximum run in R, yileding [a, ..., a].
        f    Filter, yielding either [a] (if a = n**b for some n) or [].
          L  Take the length.

Before looking at the answers, and without knowing Jelly at all, I guessed that the Jelly answer would be 12 bytes. ;)

R, 80 bytes
function(x)any((0:(m=max((d=rle(rev(utf8ToInt(c(x,''))-48)))$v[-1])))^d$l[1]==m)

Try it online!
Uses utf8ToInt - 48 to split the number into digits.  This throws a warning from the conversion to a string.
Using rle get the count of the trailing digits and the max value of the first digits.  Return true if the any of the range 0 to max value to the power of trailing count equals max value.
I think there are further golfing opportunities, but that can wait until tomorrow.

I deleted my answer because I didn't see that my post was just combining your answer and @NofP's: function(x,R=rle(rev(utf8ToInt(x)-48)))!max(R$v[-1])^(1/R$l[1])%%1 (66 bytes, taking x as a string)

@plannapus Personally I would undelete it.  It's a better count than both of ours and not really a copy of either

@plannapus I agree with MickyT!

@NofP and MickyT: OK then, here it is

R, 66 bytes
This answer is more or less a medley of MickyT and NofP's answers, and on their request, here it is:
function(x,R=rle(rev(utf8ToInt(x)-48)))!max(R$v[-1])^(1/R$l[1])%%1

It takes x as a string.
> f=function(x,R=rle(rev(utf8ToInt(x)-48)))!max(R$v[-1])^(1/R$l[1])%%1
> f("41802000")
[1] TRUE
> f("100")
[1] TRUE
> f("123456788")
[1] FALSE
> f("451111111")
[1] FALSE
> f("234543454545444")
[1] FALSE
> f("12")
[1] TRUE
> f("41902000")
[1] FALSE

JavaScript (ES7), 66 bytes
Takes input as either a string or an array of characters. Returns a boolean.
f=([c,...s],m)=>s.some(n=>n-c)?f(s,c<m?m:c):!(m**(1/-~s.length)%1)

Test cases

f=([c,...s],m)=>s.some(n=>n-c)?f(s,c<m?m:c):!(m**(1/-~s.length)%1)

console.log(f(       '41802000')) // 1
console.log(f(            '100')) // 1
console.log(f(      '123456788')) // 0
console.log(f(      '451111111')) // 0
console.log(f('234543454545444')) // 0
console.log(f(             '12')) // 1

Clean, 130 128 118 93 bytes
import StdEnv
@l#(b,a)=span((==)(last l))(reverse l)
=or[n^length b==last(sort a)\\n<-[0..9]]

Defines the function @, taking a list of integer digits.
Try it online!

Python 2, 95 78 bytes

Saved seventeen bytes thanks to Rod.

def f(s,i=~0):
	while s[i]==s[~0]:i-=1
	return int(max(s[:-~i]))**(1./~i)%1==0

Try it online!

You don't need o sort, you can just get the max, and since you already got i you can drop the len reaching 78 bytes

C (gcc), 144 126 117 bytes

Saved eighteen bytes thanks to Dennis.
Saved nine bytes thanks to ceilingcat.

j,k,m;f(char*N){N+=j=strlen(N);k=~j;for(j=-1;m=N[j--]==N[j];);for(;k++<j;)m=fmax(N[k],m);j=!fmod(pow(m-48,1./~j),1);}

Try it online!

R, 93 bytes
function(x){n=nchar(x)
d=x%/%10^(n:1-1)%%10
i=max(which(d!=d[n]))
max(d[1:i])^(1/(n-i))%%1>0}

Try it online!
The code takes an integer as input and returns FALSE if the number is pleasing, and TRUE otherwise.

Python 3, 88 85 bytes
def f(n):p=n.rstrip(n[-1]);a=int(max(p));b=len(n)-len(p);return round(a**(1/b))**b==a

Ungolfed:
def is_pleasing_number( n ):
    prefix = n.rstrip(n[-1])
    a = int(max(prefix))
    b = len(n) - len(prefix)
    return round(a ** (1 / b)) ** b == a

The input argument is expected to be a digit string
The output is either True or False.
Similar to yet developed independently of Halvard’s answer but uses floating point arithmetic in a way that doesn't suffer from rounding errors until a ** (1 / b) is off by at least 0.5 from b√a which requires a value above 253 (or whatever floating point radix and mantissa length Python happens to use, see sys.float_info).
Can be modified trivially to still work with arbitrary number bases between 2 and 36.

@ovs: With a minor modification, yes. The function would have to take the base as an extra argument and pass it to the invocations of int and range. (At some point it would become more feasible to estimate the search range based ont a^(1/b) than to calculate large amounts of powers.)

Kotlin, 106 bytes
fun String.p()=split(Regex("(?=(.)\\1*$)")).let{Math.pow((it[0].max()?:'0')-'0'+.0,1.0/(it.size-1))}%1==.0

Output: true/false
Try it online!

Japt, 26 18 bytes
ó¶
o l
ñ o n qV v1

Try it online!

Takes input as  a string, returns 1 for pleasing numbers, 0 otherwise.
Short explanation:
ó¶

Take the first input and split it by values where (x,y) => x===y is true. For example '41802000' to ['4','1','8','0','2','000'].
o l

Take the array from the first step, remove the last element and get its length, yielding B.
ñ o n qV v1

Find the largest element in the remaining array, yielding A, take it to the power 1/B and then return if the result is divisible by one.

First time working with Japt, very open to any recommendations.
Shaved off 8 bytes thanks to ETHproductions.

Hey, welcome to Japt! Sorry I missed your answers at first. A few tips: 1) You can use an auto-function to turn the first line into just ó¶. 2) Not sure why you have the v in the second line, as it just converts the string to lowercase and has no effect on the length ;-) 3) You can avoid the !(U on the last line by changing %1 to v1, which returns 1 if the subject is divisible by 1 or 0 otherwise.

@ETHproductions Thanks a lot for your feedback, really appreciate it. I read about auto-functions before, but I still haven't quite gotten the hang of it, thanks for the example. I've incorporated the rest of your changes too, adding up to a total of 8 bytes lost.

Ruby, 64 bytes
->a{!([a[/(\d)\1*$/].size,$`.chars.max]*?x!~/x1$|^2x[49]|^3x8/)}

Input as a string, returns true if:

B==1 (no need to check A)
A==4 and B==2
A==9 and B==2
A==8 and B==3

Try it online!

Perl 6, 55 bytes
{m/(\d+?)((\d)$0*)$/;so any(^10)**$1.comb==$0.comb.max}

Try it online!
After the evaluation of the initial regex--which can only succeed if the input is a positive integer--$0 contains the initial part of the number, and $1 contains the trailing repeated digits.
The comb method without arguments, applied to a string, returns a list of the characters, which in numeric context evaluates to the length of the list.  So $0.comb.max is the largest of the digits in the prefix, and $1.comb is the length of the suffix.
We then check whether any(^10) (ie, the or-junction of the numbers from 0-9), when raised to the power of the length of the suffix, is equal to the largest digit in the prefix.  The so forces boolean evaluation of the resulting junction, which would otherwise be just fine on its own as a truthy value, but the challenge calls for just two distinct values to be returned.

This is late, but since the input is guaranteed to be an integer, the regex can use . instead of \d.

C# (.NET Core), 132 bytes
n=>{int A=0,B=1,s=1,i=n.Length-1;for(;i-->0;)if(n[i]==n[i+1]&s>0)B++;else{A=n[i]>A?n[i]:A;s=0;}return System.Math.Pow(A,1d/B)%1==0;}

Try it online!
Acknowledgements
-12 bytes thanks to @KevinCruijssen
DeGolfed
n=>{
    int A=0, // maximum digit
        B=1, // count of trailing identical numbers
        s=1, // 1 if dealing with trailing numbers, 0 otherwise
        i=n.Length-1;

    for(; i-- > 0;)
        if(n[i] == n[i+1] & s > 0)
            B++;
        else
        {
            A = n[i] > A? n[i] : A;
            s = 0;
        }

    return Math.Pow(A, 1d/B) % 1 == 0;
}

I know it's been a while, but i=n.Length-2;for(;i>=0;i--) can be golfed to i=n.Length-1;for(;i-->0;) and && can be golfed to &.

Oh, and you can golf 6 more bytes by removing the using System; and using System.Math.Pow directly.

One last thing. You currently take a list of characters, but it's also allowed to take a list of digits. In which case the -48 can be golfed for -3 bytes.

Add++, 21 bytes
L,BGubLV@¦+bMG1$/^1%!

Try it online!
It's been 3 and a half months, I hope I'm not ninja'ing anyone.

Clojure, 168 bytes
(fn[x](let[y(reverse(vec x))z(count(take-while #(= %(first y))y))a(apply max(map #(-(int %)48)(drop z y)))b(Math/pow a(/ 1 z))](<(Math/abs(- b(Math/round b)))0.00001)))

Try it online!

Charcoal, 33 bytes
≔ＥＳιθ⊞υ⊟θＷ⁼§υ⁰§θ±¹⊞υ⊟θ¬﹪ＸＩ⌈θ∕¹Ｌυ¹

Try it online! Link is to verbose version of code. Outputs a - for pleasing numbers. Explanation:
≔ＥＳιθ

Split the input q into characters.
⊞υ⊟θ

Remove the last character from q and push it to u (predefined to an empty list).
Ｗ⁼§υ⁰§θ±¹⊞υ⊟θ

Repeatly pop and push while the last character of q is the first character of u.
¬﹪ＸＩ⌈θ∕¹Ｌυ¹

Take the maximum digit of q and raise it to the power of the reciprocal of the length of u, then check whether the result is an integer.

Python 2, 91 85 bytes
s=`input()`;d=0
p=s.rstrip(s[-1])
exec"`d**(len(s)-len(p))`==max(p)>exit(1);d+=1;"*10

Try it online!

Perl 5, 73 + 1 (-p) = 74 bytes
s/(.)\1*$//;$/=length$&;$_=(sort/./g)[-1];$q=$"++**$/while$q<$a;$_=$q==$a

Try it online!

Java 8, 125 bytes
a->{int A=0,B=1,f=1,i=a.length-1;for(;i-->0;)if(a[i]==a[i+1]&f>0)B++;else{A=a[i]>A?a[i]:A;f=0;}return Math.pow(A,1d/B)%1==0;}

Port of @Ayb4btu's C# .NET answer.
Try it online.
Explanation:
a->{                       // Method with digit-array parameter and boolean return-type
  int A=0,                 //  Maximum digit `A` as specified in the challenge description
      B=1,                 //  `B` as specified in the challenge description
      f=1,                 //  Flag-integer, starting at 1
      i=a.length-1;        //  Index integer `i`
  for(;i-->0;)             //  Loop `i` backwards over the digits (excluding the last)
    if(a[i]==a[i+1]        //   If the current and next digits are the same,
       &f>0)               //   and the flag is still 1
      B++;                 //    Increase `B` by 1
    else{                  //   Else:
      A=a[i]>A?            //    If the current digit is larger than `A`
         a[i]              //     Replace `A` with the current digit
        :                  //    Else:
         A;                //     Leave `A` the same
      f=0;}                //    Set the flag-integer to 0
  return Math.pow(A,1d/B)  //  Return if `A` ^ (1/`B`)
    %1==0;}                //  is an exact integer

Pip, 32 22 21 bytes
'.N(#a-#Ya<|a@v)RTMXy

Uses 1 for falsey and 0 for truthy, saving a byte. Try it online!

Pyth, 29 bytes
JezWqezJ=Pz=hZ)K@sh.MsZzZqKsK

Test suite
Python 3 translation:
Z=0
z=input()
J=z[-1]
while z[-1]==J:
    z=z[:-1]
    Z+=1
K=max(map(int,z))**(1/Z)
print(K==int(K))