[Question]
  [
Today, you're going to be writing Polish. No, not Polish notation—*Polish*, the actual language spoken in Poland.
Given a number and a noun, output a Polish sentence telling me that there are that many of that thing, using the appropriate template below.
The input consists of an integer in the range from 0 to 200, and a string of 1 to 10 lowercase ASCII letters (the "input noun"). You may accept these inputs in any reasonable format.
The output must consist of one of the below output templates, where the number in the template (if any) has been replaced with the input integer, and the word `kot` in the template has been replaced with the input noun.
## Output templates
If the input number is 0, then use the output template
```
Nie ma żadnych kotów.
```
If the input number is 1, then use the output template
```
Jest 1 kot.
```
If the input number ends with 2, 3, or 4, but does **not** end with 12, 13, or 14, then use the output template
```
Są 4 koty.
```
In any other case, use the output template
```
Jest 8 kotów.
```
Note that the special characters used in these templates are:
* ż (in "żadnych") – U+017C Latin small letter Z with dot above (&zdot;)
* ó (in the suffix "-ów") – U+00F3 Latin small letter O with acute (&oacute;)
* ą (in "Są") – U+0105 Latin small letter A with ogonek (&aogon;)
You may output these characters in any reasonably common character encoding (including HTML entities), and you may use combining characters instead of precomposed characters (or even a mixture of the two).
Note that in [ISO-8859-2](https://en.wikipedia.org/wiki/ISO/IEC_8859-2), all ASCII characters as well as the three special characters above are represented with one byte. Therefore, if your program uses no non-ASCII characters besides these three, then you can count each of these three characters as one byte.
## Test cases
```
0 pomidor -> Nie ma żadnych pomidorów.
1 kwiat -> Jest 1 kwiat.
2 dom -> Są 2 domy.
5 wilk -> Jest 5 wilków.
13 komputer -> Jest 13 komputerów.
24 but -> Są 24 buty.
101 kurczak -> Jest 101 kurczaków.
104 wieloryb -> Są 104 wieloryby.
112 post -> Jest 112 postów.
122 balon -> Są 122 balony.
```
## Do plurals in Polish really work that way?
No, plurals in Polish are actually a lot more complicated than this.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest program in each language wins.
  
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 88 bytes
```
.+
Jest $&ów.
Jest 0
Nie ma żadnych
( 1 .+)...
$1.
Jest (.*(?<!1)[2-4] .+)...
Są $1y.
```
[Try it online!](https://tio.run/##NcyxCsIwFIXh/T7FFYpUiyE31k1wd3BxFIe0DRjaNCVNKXX3iVzd1OeKAXU78H8cp7xuZQgsg73qPSbz531k383hoBUaie@HrNqpvECKhCxbMMYgoZ9K2TLdbWe0OIlVfv7n4@uGCU0sBI6dNbqyDgjrUUsPAitrYIOjbmqgNdbWdINXDkSOxeCBeJSDK68yZp5HpxrrpgKIRDzroxACC9nY9gM "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
.+
Jest $&ów.
```
Assume none of the special cases apply.
```
Jest 0
Nie ma żadnych
```
Fix up if the input was `0`.
```
( 1 .+)...
$1.
```
Fix up if the input was `1`.
```
Jest (.*(?<!1)[2-4] .+)...
Są $1y.
```
Fix up for the `2-4` but not `12-14` endings.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~105~~ ~~92~~ 89 bytes
*-16 thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen).*
```
„ówU’Jî• ’V>iXIŽ1}ç’NíÓ íà ÿ‹¤½Áh ’rJë¹iY…ÿ1 ìë¹Ƶ…S©Å¿O¹®T+Å¿O_*i¹Ƶ¡ç"Sÿ ÿ ÿy"ëY¹ðIXJ]'.J
```
[Try it online!](https://tio.run/##yy9OTMpM/f//UcO8w5vLQx81zPQ6vO5RwyIFICvMLjPC8@hew9rDy4E8v8NrD09WABILFA7vf9Sw89CSQ3sPN2aAFBZ5HV59aGdm5KOGZYf3GyocXgPiHtsK5AYfWnm49dB@/0M7D60L0QYz47UyQZKHFh5erhR8eL8CGFUqHV4deWjn4Q2eEV6x6npe//8bGphwlWem5uQXVSYBAA "05AB1E – Try It Online") Takes input separated by a newline.
[Answer]
# [Factor](https://factorcode.org), 160 bytes
```
[| n s | n s t n 0 = n 1 = n present R/ .*(?<!1)[234]/ matches? 3array index ?1+
{ "Jest %d %sów.""Nie ma żadnych %sów.""Jest %d %s.""Są %d %sy."} nth sprintf ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=TVG7TsMwFBVrvoDxYKkSD_WRtEiIhzoiGDpQMVUdXOe2jZrawXbUhtKRr2DpAPwAKxvwEfA1OE2h8XDse3zP0dW5T69DLqzSq5-d3dvuVefyFFxrnhlwY5QwGCo95dZGcoRIYUJaUoxYCR4buI8xEk2GpIWmEc0TGLpLSQoyOPO8hQd3FmiAJWoahUozLDecDzaZRdxumQAsVNNtfQw2i-JJSdJ0GjVNUkslo6AFNkhLPn4j9061uOdlcaOV-1GsdDYo0X6QD2fK-sBRAx4rmXNL7yW1w-rJ93PvARIGBVqHDVw49Nf4F8NNHbXD_fb5nn_QC5qtfj1PSYzJtNFcJ4tIhjRH2z_yFmDXZCwqISrm421WY6wTkRPg652HMhPjf37b54ru52PxzmpsCemWYBIdSTtEfzMr62HNoA_hAlOGin1WiTtTERPXRedqVdy_)
### How?
```
                   ! n = 122, s = "balon"
n                  ! 122
s                  ! 122 "balon"
t                  ! 122 "balon" t
n                  ! 122 "balon" t 122
0                  ! 122 "balon" t 122 0
=                  ! 122 "balon" t f
n                  ! 122 "balon" t f 122
1                  ! 122 "balon" t f 122 1
=                  ! 122 "balon" t f f
n                  ! 122 "balon" t f f 122
present            ! 122 "balon" t f f "122"
R/ .*(?<!1)[234]/  ! 122 "balon" t f f "122" R/ .*(?<!1)[234]/
matches?           ! 122 "balon" t f f t
3array             ! 122 "balon" t { f f t }
index              ! 122 "balon" 2
?1+                ! 122 "balon" 3
{ ... }            ! 122 "balon" 3 { ... }
nth                ! 122 "balon" "Są %d %sy."
sprintf            ! "Są 122 balony."
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~109~~ 106 bytes
```
lambda n,s:[['Nie ma żadnych ','Jest %s '%n][n>0]+s+'ów'*(n!=1),f'Są {n} {s}y'][n//10%10!=1<n%10<5]+'.'
```
[Try it online!](https://tio.run/##XY@xboMwEIZ3nuI6RIaGOpgkSxTyAB26dKQZTABhATbCRohGGftEXbu1fS5qAyFRF9v33@/v7q86lQm@7tPgrS9oGcUUuCt3YYheWAIlhd8vGvPulAFy0XMiFSwkoAU/hvzgHZdyib4/W/Ro84eAOG6KXn8@4MwvcJaXDmnTakW8BfF0d8/1vd8elwijvs1YkQDZWcB45YJoVAWBeTfKdrCsCqZsBE8HQI6lFwI5dqeO1qqacWWntjm5ow0OBMHAcXoPKlGyWNQG8D/G1NJbY4tA3jKqjG2INtXY8iEWpZFNnKHosLWFlhX5bB7LkbOGXJR696S@sW7a4PE3EDVqZg6VhhJPD23q0zu9ke@0Ee9t9KykEHUXXQH3msEQXyeTd1EmYQT4PkS0EHz@fRU6/Ac "Python 3 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) + `-pl056`, 79 bytes in ISO-8859-2
```
/ /;$_=/(?<!1)[234] /?"Są ${_}y":$`?"Jest $_"."ów"x($`>1):"Nie ma żadnych $'ów"
```
[Try it online!](https://tio.run/##XY/NUoMwFEb3fYprytTWGRKgxUVRundGNy4dp01LFAQSJgmD6Lj0idy6U19LDNC/cXlPbs53v4LJzG8UATvEZ4QEMHwqlYaYSQYPQoKOGWxEUZOCKm2QFHnHNDNbG6qYagiQwFpekvHi4sSd3HnT2T2QBbr9fgfrdflWo7m1WqCr9oO1RBh9fVToeWytQncyRzcJg5zCzyeNeL2JwTptn5vAwqE7GilaIxQMc5oy1cVKpspMK2BUJcxcJwyhEVQx4yBLzhP@CLkwt@uYchC8P7RxoBB5Epk@dgj/I7dPJhcPXEirhOp2rTt4O@OBB5FpbnBbqxtqPPChSrJ0v9yPvWcKqciLUjN5cB1Yt@PNYF3qvbObjNR1TGgpNy/0YD5ivd6ZmSyWCVmvd4Jj1mpczzRTR1W2oBd4HqxpJvj@9w7U@FcUOhFcNXaROf55Y1/72HGdPw "Perl 5 – Try It Online")
## Explanation
Match space with `/ /` which stores the number in prematch (`$`` ) and the noun in postmatch (`$'`). Next `$_` (which is automatically output, thanks to `-p`) is set to `"Są ${_}y"` (where `$_` is the implicit input from the implicit `-n` via `-p`) if it matches the regex `/(?<!1)[234] /` (number ends `[234]` but not `1[234]`), otherwise if `$``  is not `0` it's set to `"Jest $_"."ów"x($`>1)`, where the` "ów"`suffix is added if`$'`is greater than`1`, otherwise, finally for the` 0`case it's set to`"Nie ma żadnych $'ów"`.
Thanks to [@Xcali](https://codegolf.stackexchange.com/users/72767/xcali) for saving 9 bytes!
[Answer]
# [Python](https://www.python.org), ~~138~~ ~~123~~ 111 bytes
```
lambda n,s:("Nie ma żadnych ",("Jest","Są")[(z:=n//10%10!=1<n%10<5)]+f' {n} ')[n>0]+s+(n!=1)*"óyw"[z::2]+'.'
```
[Attempt This Online!](https://ato.pxeger.com/run?1=XZLBbptAFEWl7Myi3_AyUgTEJIGJLVUoZNNdFtl0SVmMw0yDAjOIGeRgy8t-RTaWovYHvO0uzUe0X9MHY5uqq9G793LuY-DlR92ZRyW3ryL58r014uLjb1WyapEzkIGOPXJfcKgYvP9kueweHoEEHrnj2pCAfP71jfipt4oTeXUVhWdReJpENxLPm7mfTYULa7kB10_lbZhN9dST6Pvn5G3XLUm6imOaTd1L19b-OflgEKuT1EnDAEitqiJXDdb8v8HeedstL0kWOGmE6adlwXAlGFaDCIbZ2hTVXFW9iQsDBRw6a81RWxbl0_HBOfTjSL7u0aqqW8ObkX4NB-2YpDN0F605tswAp31NFA4rts3Dio1dqMJeGwvD2bASL1XTLQ4wVOGgHZARHe5I__PSEYVeGGG0zyxYqeSRRCkMgsVkjlANyLYKQJumkF8DaLhuSwOFhOFrxM6kEOA9x4nw-pyN-f5pYoPoT2qUjCfIJ6Y5uGuMbQJY2-TGBcGKkudwAao1eGmgBIaeNy7xnQkvNR8RllAzrXlOfPtbbLf2_As)
[Answer]
# JavaScript (ES6), 113 bytes\*
*\* counting each special letter as 1 byte, as allowed by the challenge*
Expects `(integer)(word)`.
```
n=>w=>[`Jest`,`Są`,`Nie ma żadnych`][i=n<2?n+2:28>>n%10&n*9%98%9!=1,i%3]+` ${n?n+' '+w:w}${[[,'y','ów'][i||2]]}.`
```
[Try it online!](https://tio.run/##bZFBU4JQFIX3/YrbGwlNQt5TZ9QJ2rdo05JhBgSsl/CeAxhD6rJf5LZd9bvoQjqlsGFx7vnuPefx4r16qZ/wVXYjZBCWC7MUppWblu3eh2nmau7j1zt@H3gIsQffH14gCv/ZdWxuilt2J/psxiaWJRRqXInrqTKdKNNLk2pcGTp9FzobgR4V1H4@y3edjW1raqFq6uc@V3HHdsscZ6e7pS9FKqNQj@RTd9EFMHpdspIxD2RCoNeDwQDOIsBhjJv0i3OcIr7MuZcRgANe1QEKtdoEGAKBjCv7EcDiwADFomkfoz3n0ZLA6f4xVGpbJDqsIsl4tc7ChPyPNISj3MaxEXLzddZINgJUG9GoUVdfJ/6btyQn1Q0s/6u33KHGqK4URjIp5uTvDg7gKDevUVb/pzQ7fwicQKW3nWIVNPciKchJJRxALRd6@QM "JavaScript (Node.js) – Try It Online")
### How?
To test whether \$n\$ ends with \$2\$, \$3\$ or \$4\$ and does not end with \$12\$, \$13\$ or \$14\$, we use the expression:
```
28>>n%10&n*9%98%9!=1   // 20 bytes
```
Explanation:
```
28                     // the bitmask 0b0000011100
>> n % 10              // right-shifted by n mod 10
&                      //
n * 9 % 98 % 9 != 1    // this is false for 12, 13, 14, 112, 113, 114
                       // and true for other values ending with 2, 3, 4
                       // (for anything else, it doesn't matter)
```
This is somewhat convoluted but shorter than using a test with a regular expression (which would also require ES9+ for the negative lookbehind assertion):
```
/(?<!1)[234]$/.test(n) // 22 bytes
```
[Try it online!](https://tio.run/##NY5BTsMwFET3OcVUAvzdGjdJu2hp0x6iy6oLqw1VqmA7jsUGuAESG5ZwD87TC3CE8L3gL@aP5s1iLubZ9MfQ@Hhv3akehkcXqK0jLCrkK37rCmWe3GQi8ZIBiXqm5QKbDRduUeSK83Qd5xZjLDldLpL8k8DE4w7UYVShkKuMwdHZ3rW1bt2Z9lbBK3QKQaV2hSlt16NC7svZ/HAz1bHuI1mJLcTvz8f165NV4AHi@v0uDvrJeOLRvEhHt4uhsWeS2pvTLpoQaSalvrjGksArhJTZ2zD8AQ "JavaScript (Node.js) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 73 bytes
```
≡θ0«Nie ma żadnych ηów»¿›№234§θ±¹⁼1§θ±²«Są θ ηy»«Jest θ η¿⁻1θów».
```
[Try it online!](https://tio.run/##S85ILErOT8z5/7@4PLMkOUNBo1BToZorObE4VUHJQMkKyOYMKMrMK9FQ8stMVchNVDi6JzElrxKoUknTGiaXgWAqHd5cDpKp5UpJTUsszSmxUshMU9BwL0pNLEkt0nDOLwUpMjI2UdJRcCzxzEtJrdAo1FHwS00HymsYampq6ii4FpYm5hRrKBliVWOkCQJIDgs@0orsmEIkx@ByZCXYiQqpOUBvIgzySi0uIdokkK98M/NKoe4sBDoJPQRquaAiekD@//@GRkYKSYk5@Xn/dctyAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≡θ0«Nie ma żadnych ηów»
```
If the first input (`θ`) is `0`, then print `Nie ma żadnych ηów`, where `η` is the second input.
```
¿›№234§θ±¹⁼1§θ±²«Są θ ηy»
```
If it ends in `2`, `3` or `4` but not `12`, `13` or `14`, then print `Są θ ηy`.
```
«Jest θ η¿⁻1θów»
```
Otherwise print `Jest θ η`, and then print `ów` if the first input is not `1`.
```
.
```
Print the final `.`.
Note that the deverbosifier thinks that `ó` doesn't need to be encoded but it actually takes three bytes to encode. (It calculates the byte count correctly for ż and ą.)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 74 bytes
```
`J½Ḣ Π Π.`¹ċ[Ṫ£234¹tc¹Ṫtċ∧[⁺żC`SΠ Π Πy.`|⁺ċC¹[¥`ΠΠw.`|⁰`Nie ma \ż…ṅƒ꘍ ΠΠw.
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgSsK94biiIM6gIM6gLmDCucSLW+G5qsKjMjM0wrl0Y8K54bmqdMSL4oinW+KBusW8Q2BTzqAgzqAgzqB5LmB84oG6xItDwrlbwqVgzqDOoHcuYHzigbBgTmllIG1hIFxcxbzigKbhuYXGkuqYjSDOoM6gdy4iLCIiLCIxMDRcbndpZWxvcnliIl0=)
## How?
```
`J½Ḣ Π Π.`¹ċ[Ṫ£234¹tc¹Ṫtċ∧[⁺żC`SΠ Π Πy.`|⁺ċC¹[¥`ΠΠw.`|⁰`Nie ma \ż…ṅƒ꘍ ΠΠw.
`J½Ḣ Π Π.`                   # Push string "Jest {implicit first input} {implicit second input}."
          ¹ċ                 # Is the first input not one?
            [                #  If so:
             Ṫ               #   Remove the last character (the period) from the string
              £              #   Pop and put it in the register.
               234¹tc        #    Is the last digit of the first input one of 2, 3, 4?...
                     ¹Ṫtċ∧   #    ...and is the second last digit of the first input not one?
[                            #     If so:
 ⁺żC                         #      Push "ą"
    `SΠ Π Πy.`               #      Push string "S{'ą'} {implicit first input} {implicit second input}y." (which is implicitly output)
              |              #     Otherwise:
               ⁺ċC           #      Push "ó"
                  ¹          #      Is the first input truthy? (not zero)
                   [         #       If so:
                    ¥`ΠΠw.`  #        Push string "{register}{'ó'}w." (which is implicitly output)
|                            #       Otherwise (the input is zero):
 ⁰`Nie ma \ż…ṅƒ꘍ ΠΠw.        #         Push string "Nie ma żadnych {second input}{'ó'}w." (which is implicitly output)
                             # All strings and if statements implicitly closed.
                             # If the first if statement was falsy (aka the input was one), then the string pushed at the beginning will be implicitly output.
```
[Answer]
# [APL(Dyalog Unicode)](https://dyalog.com), 105 bytes [SBCS](https://github.com/abrudz/SBCS)
```
{⍺=0:∊'Nie ma żadnych '⍵'ów.'⋄⍺=1:∊'Jest 1 '⍵⋄1 0≡(2 3 4∘+¨0 10)∨/⍤∊¨10 100|⍺:∊'Są'⍺⍵'y.'⋄∊'Jest'⍺⍵'ów.'}
```
[Try it on APLgolf!](https://razetime.github.io/APLgolf/?h=AwA&c=q37Uu8vWwOpRR5e6X2aqQm6iwtE9iSl5lckZCuqPereqH95crqf@qLsFpMwQrMwrtbhEwRAsCxQ3VDB41LlQw0jBWMHkUccM7UMrDBQMDTQfdazQf9S7BKj@0ApDkIhBDdAEsP7gI61AvbtAhldCjIYaChMFW1kLAA&f=XZA9DoIwGIZ3T/FtTBIosHoABxdPUKDGBkoJlhDcddO4OHoKVzf1Ij2JbUOxsD7v39fK612ebwHsvJozmvPGA3l5wHIFG0qAYfi@cF712R4G/f3s/IU0qVClio5iMWbW5CAgBAOtCylXztno2X5OgECR3joS5ehoWUxrEtDMnYv0Hmd1K0gzm4zACk4AxSqQtmI6HYNC43YYmFe0TXbEswO0NAjuFUFsziUlb/p0Uq0lK/wHQmQ@9zD/JcU1dauRtqa45NW0V3FDe/8H&i=AwA&r=tryapl&l=apl-dyalog&m=dfn&n=f)
Ironic.
]