OUPC 2023 Day1のAをいろいろな言語で解く

[こちら](https://atcoder.jp/contests/oupc2023-day1/tasks/oupc2023_day1_a)の問題です。

ACが不可能であるTextを除いた全ての言語について、ACが確認出来ました。

# ><>
```
0i:48*=?v4c*-$a*+!
v    0:~<
>i:a=?v'0'-+a*
-&,n; >,r~1-:r:&%
```

# AWK
```awk
{print int(($1-1)/$2)}
```

# Ada
<!-- 
[Ada](https://www.adaic.org/)
https://learn.adacore.com/
-->
```ada
with Ada.Integer_Text_IO;

procedure Main is
  A, T : Integer;
begin
  Ada.Integer_Text_IO.Get(A);
  Ada.Integer_Text_IO.Get(T);
  Ada.Integer_Text_IO.Put((A - 1)/T,0);
end Main;
```
<!-- 文字列の入出力
```ada
with Ada.Integer_Text_IO;
with Ada.Text_IO;

procedure Main is
  S : Character;
begin
  Ada.Text_IO.Get(S);
  Ada.Text_IO.Put(S);
end Main;
```
-->

# Assembly x64
```nasm
section .data
  int_in_format db "%d", 0
  int_out_format db "%d", 10, 0

section .bss
  a resb 4
  b resb 4

section .text
  global main
  extern scanf, printf

main:
  sub rsp, 8
  lea rdi, [rel int_in_format]
  lea rsi, [rel a]
  call scanf WRT ..plt
  lea rdi, [rel int_in_format]
  lea rsi, [rel b]
  call scanf WRT ..plt
  
  mov eax, [rel a]
  sub eax, 1
  mov ecx, [rel b]
  div ecx

  lea rdi, [rel int_out_format]
  lea rsi, [eax]
  call printf WRT ..plt
  
done:
  add rsp, 8
  mov rax, 0
  ret
```

# bash
```bash
read A T
echo $(((A-1)/T))
```

# Brainfuck
```brainfuck
[-]>>>>>>>[<<<<<<<+>>>>>>>>+<-]>[-]+<<<<<<<[-]>>>>>>>[<<<<<<<+>>>>>>+>-]<[-]<<<<<[-]>>>>>[<<<<<+>>>>>>+<-]>[-]<<<<<<[>>>>>>+<+<<<<<-]>>>>>[<<<<<+>>>>>-]++++>[-<[>>+>+<<<-]>>>[<<<+>>>-]+<[<<->>>-<[-]]>[<<[-]>>-]<<]<[>+<[-]]>[<<<<<<<[>>>>>>+>>+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]+<<[>>-<<-]+>>[<<->>[-]]+<<[>>>>,<<<<<<<<[-]>>>>>>>>[<<<<<<<<+>>>>>>>>>+<-]>[-]<<<<<<<<<[>>>>>>>>>+<+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>>++++++[<<++++++++>>-]<[-<[>>+>+<<<-]>>>[<<<+>>>-]+<[<<->>>-<[-]]>[<<[-]>>-]<<]<[>+<[-]]>>+++++++[<<++++++++>>-]<<+<<<<<<<<[>>>>>>>>>>+>+<<<<<<<<<<<-]>>>>>>>>>>>[<<<<<<<<<<<+>>>>>>>>>>>-]<<<[->>[>+>+<<-]>>[<<+>>-]+<[<->>-<[-]]>[<<<<[-]>>>>-]<<<<]>>[<<+>>[-]]<[>+<[-]]<[>>+<<[-]]>>[<<+>>[-]]+<<[<<<<<<<<<<[-]>>>>>>>>>>>>>[<<<<<<<<<<<<<+>>>>>>>>>>>>>>+<-]>[<<<+>>>-]<<-<<[-]]>>[<<<<<<<<<<<<<[>>>>>>>>>>>+>>>>+<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>-]++++++++++<<<<[>>>>[<+>>+<-]>[<+>-]<<<<<-]>>>>[-]<[<<<+>>>-]<<<<<<<<<<<[>>>>>>>>>>>>+<+<<<<<<<<<<<-]>>>>>>>>>>>[<<<<<<<<<<<+>>>>>>>>>>>-]>[<<<<+>>>>-]<++++++[>++++++++<-]>[<<<<->>>>-]<<<<<<<<<<<<<<<[-]>>>>>>>>>>>[<<<<<<<<<<<+>>>>>>>>>>>>>>>+<<<<-]>>>>[<<<+>>>-]<<-]<[<<+>>-]<<<-<<[-]]>>[-]>[-]<<<<<<<<+[>>>>>>>>+<+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]>[-]<<[-]<<<<<<[>>>>>>>>+<+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]++++>[-<[<<+>>>>>+<<<-]>>>[<<<+>>>-]+<<<<<[>>->>>-<<<<<[-]]>>>>>[<<[-]>>-]<<]<[>+<[-]]>[<<+>>-]<<]<<<<[-]>>>>[<<<<+>>>>>>+<<-]>>[-]+<<<<<[-]>>>>>[<<<<<+>>>+>>-]<<[-]<<<<<<[-]>>>>>>[<<<<<<+>>>>>>>>+<<-]>>[-]<<<<<<<<[>>>>>>>>+<<+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]++++>>[-<<[>+<<+>-]<[>+<-]+>>[<-<->>[-]]<<[>>>[-]<<<-]>>>]<<[>>+<<[-]]>>[<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]+<[>-<-]+>[<->[-]]+<[>>>>,<<<<<<<<<[-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>>+<-]>[-]<<<<<<<<<<[>>>>>>>>>>+<+<<<<<<<<<-]>>>>>>>>>[<<<<<<<<<+>>>>>>>>>-]>>>++++++[<<<++++++++>>>-]<<[-<[>>>+<<<<+>-]<[>+<-]+>>>>[<<<-<->>>>[-]]<<<<[>>[-]<<-]>>]<[>+<[-]]>>>+++++++[<<<++++++++>>>-]<<<+<<<<<<<<<[>>>>>>>>>>>>+<<<<+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>[->>>[<<<<+>>>+>-]<[>+<-]+<<<[>>>>-<-<<<[-]]>>>[<<[-]>>-]<<]>>>[<<<+>>>[-]]<<[>>+<<[-]]<[>>>+<<<[-]]>>>[<<<+>>>[-]]+<<<[<<<<<<<[-]>>>>>>[<<<<<<+>>>>>>>>>+<<<-]>>>[<+>-]>-<<<[-]]>>>[<<<<<<<<<<<[>>>>>>>>+>>+<<<<<<<<<<-]>>>>>>>>>>[<<<<<<<<<<+>>>>>>>>>>-]++++++++++<<[>>[<<<+>>>>>+<<-]>>[<<+>>-]<<<<-]>>[-]<<<[>+<-]<<<<<<<<[>>>>>>>>>>>+<<<+<<<<<<<<-]>>>>>>>>[<<<<<<<<+>>>>>>>>-]>>>[<<+>>-]<<<++++++[>>>++++++++<<<-]>>>[<<->>-]<<<<<<<<<<[-]>>>>>>>>[<<<<<<<<+>>>>>>>>>>+<<-]>>[<+>-]>-]<<[<<<<<<+>>>>>>-]<<<<-<[-]]>[-]<<[-]<<<<<+[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<<[-]>>>[-]<<<<<<<<[>>>>>+>>+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]++++<<[->>[<+>>>>>+<<<<-]>>>>[<<<<+>>>>-]+<<<<<[>->>>>-<<<<<[-]]>>>>>[<<<<<<[-]>>>>>>-]<<<<<<]>>[<<+>>[-]]<<[>>>+<<<-]>>>]<<<<<<<<<<[>>>>>>>>>>+<<<+<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]+[>>>-<<<-]<<<[>>>+>>+<<<<<-]>>>>>[<<<<<+>>>>>-]>[<+>-]<[<<[>+>>>>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<<<<[>>>>>+<<<<-[>>>>[-]>>+<<<<<<-]>>>>>>[<<<<<<+>>>>>>-]<<[<<<<<-[>>-<<[-]]+>>>>>-]<<<<<-]>>+<]<<[-]<[-]>>>>[<<<<+>+>>>-]<<<[-]<[>+>>>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<<<[->>>-<+>[<<+>>>>>+<<<-]>>>[<<<+>>>-]+<<<<<[>>>>>-<<<<<[-]]>>>>>[<<<<[>+<-]>>>>>>+<<-]<<<<<<]>>[>>>+<<<-]>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<[-]++++++++++<<<[->>>-<+>[<<+>>>>>+<<<-]>>>[<<<+>>>-]+<<<<<[>>>>>-<<<<<[-]]>>>>>[<<<<[>+<-]>>>>>>+<<-]<<<<<<]>>[>>>>>+<<<<<-]>>>>>>[++++++++++++++++++++++++++++++++++++++++++++++++.<<+>+>[-]]<[<[>-<-]>++++++++++++++++++++++++++++++++++++++++++++++++.[-]]<<++++++++++++++++++++++++++++++++++++++++++++++++.[-]<<[-]
```

# C
```c
#include <stdio.h>
int main(){
    int A,T;
    scanf("%d %d",&A,&T);
    printf("%d\n",(A-1)/T);
}
```

# C#
```c#
using System;
class Program
{
    static void Main(string[] args)
	{
		string[] input = Console.ReadLine().Split(' ');
		int A = int.Parse(input[0]);
		int T = int.Parse(input[1]);
		Console.WriteLine((A-1)/T);
	}
}
```

# C++
```cpp
#include <iostream>
int main(){
    int A,T;
    std::cin>>A>>T;
    std::cout<<(A-1)/T<<std::endl;
}
```

# COBOL
```
IDENTIFICATION DIVISION.
PROGRAM-ID. Main.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 INP        PIC  X(10).
01 A          PIC  9(03).
01 T          PIC  9(03).
01 G          PIC  ZZZ9.
*> 
PROCEDURE DIVISION.
  ACCEPT INP.
  UNSTRING INP DELIMITED BY ' '
      INTO A T.
*>
  COMPUTE G = (A - 1)/T.
  DISPLAY FUNCTION TRIM(G).
*>
  STOP RUN.
```

# Carp
```
(use IO)
(use String)
(use Int)
(use Array)

(defn getnum []
  (let [ss (get-line)
        s (chomp &ss)]
    (Maybe.unsafe-from (from-string &s))
  )
)

(defn getnums []
  (let [ss (get-line)
        s (words &ss)
        nums (copy-map &Int.from-string &s)]
   nums
  )
)

(defn solve [a b]
  (let [ am (Maybe.unsafe-from a)
         bm (Maybe.unsafe-from b)
         aa (Maybe.unsafe-from am)
         bb (Maybe.unsafe-from bm) ]
   (/ (- aa 1) bb)
  )
)

(defn main []
  (let [
        tmp (getnums)
        AT (solve (first &tmp) (last &tmp))
       ]
  (do
     (print &(Int.str AT))
  )
  )
)
```

# Clojure
```clojure
(prn (quot (- (read) 1) (read)))
```

# Common Lisp
```lisp
(format t "~D" (floor (- (read) 1) (read)))
```

# Crystal
```crystal
a,t=gets.not_nil!.split.map &.to_i
puts (a-1)//t
```

# Cyber
[CYBER](https://cyberscript.dev/)
```
tmp = getInput().utf8().split(' ')
A = number(tmp[0])
T = number(tmp[1])
print int((A-1)/T)
```
<!-- 
```
S = getInput()
n = S.len()-1
ans = 0
t = -1
for 0..n each i:
    if S[i]==S[i+1]:
        ans += (i-t)*(n-i)
        t = i
print ans
```
-->

# D
```d
import std.stdio;
import std.string;
import std.conv;
void main()
{
	string[] input = split(readln());
	int A = to!int(input[0]);
	int T = to!int(input[1]);
	writefln("%d", (A-1)/T);
}
```

# Dart
```dart
import 'dart:io';

void main() {
  String tmp = stdin.readLineSync()!;
  int A = int.parse(tmp.split(" ")[0]);
  int T = int.parse(tmp.split(" ")[1]);
  print("${(A-1)~/T}");
}
```

# ECLiPSe
```
:- lib(ic).

main :-
        read_num(A),
        read_num(T),
        Ans #= (A-1) // T,
        printf("%d%n", [Ans]).

read_str(S) :-
        read_string(user_input, " \n", "", _, S).

read_num(N) :-
	read_str(S),
	number_string(N, S).
```

# Elixir
```elixir
defmodule Main do
  def main do
    [a,t] = IO.read(:line) |> String.trim() |> String.split(" ") |> Enum.map(&String.to_integer/1)
    div(a-1, t) |> IO.puts()
  end
end
```

# Emacs Lisp
```emacs-lisp
(set-buffer (get-buffer-create "*stdin*"))
(while (ignore-errors (insert (read-string "") "\n") t))
(goto-char (point-min))
(setq standard-input (get-buffer "*stdin*"))

(princ (format "%s" (floor (- (read) 1) (read))))
```

# Erlang
```erlang
-module('Main').
-export([main/1]).

main(_) ->
    {ok, [A, T]} = io:fread("", "~d~d"),
    io:format("~B ~n", [(A - 1) div T]),
    halt().
```

# F#
```fsharp
let a,t = stdin.ReadLine().Split(" ") |> fun x ->int x[0],int x[1]
printfn "%i" ((a-1)/t)
```

# Factor
```factor
USING: kernel io sequences splitting math math.parser ;
readln
" "
split
[ string>number ] map
first2
swap
1
-
swap
/i
number>string
print
```

# Forth
```
: read-all begin key drop key dup 4 <> tuck if ( emit ) else drop then invert until ; ( read until EOF )
: read-number 0 0 begin swap 10 * + key 48 - dup 0 < until drop ;
: to-bin begin 2 /mod swap 1+ swap dup 0= until drop ; ( convert number to bin array )
: write-pure ( d --  ) dup 0<> if dup 0< if ." -" negate then -1 swap begin dup 0 <> while 10 /mod repeat drop begin dup -1 <> while 48 + emit repeat drop else ." 0" then ;
: write-cr ( d --  ) write-pure cr ;

read-number read-number 
swap 1 - swap /
write-cr
```

# Fortran
```fortran
program main
  implicit none
  integer :: A,T
  read(*,*) A,T
  print '(i0)', (A-1)/T
end program main
```

# Go
```go
package main

import (
	"fmt"
)

func main() {
	var A, T int
	fmt.Scanf("%d %d", &A, &T)
	fmt.Printf("%d\n", (A-1)/T)
}
```

# Haskell
```haskell
main :: IO ()
main = do
    [a, t] <- map read . words <$> getLine
    putStrLn $ show ((a - 1) `div` t)
```

# Haxe
```haxe
using Std;
class Main {
	static function main() {
		var args=Sys.stdin().readLine().split(" ").map(v -> v.parseInt());
		var A=args[0],T=args[1];
		Sys.println(Math.floor((A-1)/T));
	}
}
```

# Java
```java
import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int A = sc.nextInt();
		int T = sc.nextInt();
		System.out.println((A-1)/T);
	}
}
```

# JavaScript
```js
function Main(input) {
	input = input.split("\n");
	tmp = input[0].split(" ");
	var A = BigInt(tmp[0]);
	var T = BigInt(tmp[1]);
	console.log(((A - 1n) / T).toString());
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
```
<!--
console.log('%d',((A-1-(A-1)%T)/T).toFixed());
-->

# Julia
```julia
A,T=parse.(Int,split(readline()))
print((A-1)÷T)
```

# Koka
```
import std/os/readline

fun main()
    val [a, t] = readline().split(" ").map(fn(s) { s.parse-int.unjust })
    println((a - 1) / t)
```

# Kotlin
```kotlin
fun main(args: Array<String>) {
    val (A,T) = readln().split(' ').map { c -> c.toInt() }
    println(String.format("%d", (A-1)/T))
}
```

# LLVM IR
```llvm
@.str = private unnamed_addr constant [6 x i8] c"%d %d\00", align 1
@.str.1 = private unnamed_addr constant [3 x i8] c"%d\00", align 1
define dso_local i32 @main() #0 {
  %1 = alloca i32, align 4
  %2 = alloca i32, align 4
  %3 = call i32 (i8*, ...) @__isoc99_scanf(i8* noundef getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32* noundef %1, i32* noundef %2)
  %4 = load i32, i32* %1, align 4
  %5 = sub nsw i32 %4, 1
  %6 = load i32, i32* %2, align 4
  %7 = sdiv i32 %5, %6
  %8 = call i32 (i8*, ...) @printf(i8* noundef getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 noundef %7)
  ret i32 0
}
declare i32 @__isoc99_scanf(i8* noundef, ...)
declare i32 @printf(i8* noundef, ...)
```

# Lua
```lua
A, T = io.read("*n", "*n")
print((A - 1) // T)
```

# Mercury
```
:- module main.
:- interface.

:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.
:- import_module int, list, string.

main(!IO) :-
   io.read_line_as_string(Result, !IO),
   ( if
        Result = ok(Line),
        [AStr, TStr] = string.words(Line),
        string.to_int(AStr, A), string.to_int(TStr, T)
     then
        io.format("%d\n", [i((A - 1)/T)], !IO)
     else
        true
    ).
```

# Nibbles
```
/-$1;$
```

# Nim
```nim
import strutils, sequtils
var
    tmp=readLine(stdin).split().map(parseInt)
    A=tmp[0]
    T=tmp[1]
echo (A-1) div T
```

# OCalm
```ocaml
let () = 
  let a, t = Scanf.scanf " %d %d" (fun i j -> (i, j)) in
  let res = (a - 1)/t in
  Printf.printf "%d\n" res
```

# Octave
```matlab
[A T] = scanf("%d %d", 'C');
printf("%d\n", floor((A-1)/T))
```

# PHP
```php
<?php
fscanf(STDIN, "%d %d", $A, $T);
echo intdiv($A-1,$T)."\n";
?>
```

# Pascal
```pascal
var
    A, T : integer;
begin
    read(A);
    readln(T);
    writeln((A-1) div T);
end.
```

# Perl
```perl
my $input = <STDIN>;
chomp $input;
my ($A, $T) = split / /, $input;
$ret = int(($A - 1)/$T);
print "$ret\n";
```

# PowerShell
```powershell
$A,$T= ([Console]::ReadLine()) -split ' '
[int][Math]::Floor(($A - 1) / $T)
```

# Prolog
```prolog
main :-
  read_num(A),
  read_num(T),
  Res is (A - 1) // T,
  write(Res),
  nl.

read_str(S) :-
  read_string(current_input, ' \n', '', _, S).

read_num(N) :-
	read_str(S),
	number_string(N, S).
```

# Python
```py
A,T = map(int, input().split())
print((A-1)//T)
```

# R
```r
library(magrittr)

s <- readLines("stdin", n=1) %>% strsplit(" ") %>% unlist %>% as.integer

A <- s[1]
T <- s[2]

cat((A - 1) %/% T)
```

# Raku
```
$/=words>>.Int;say ($0-1) div $1
```

# ReasonML
```reasonml
let inp = read_line();
let res = Scanf.sscanf(inp,"%d %d", ((a, t) => (a-1)/t));
print_endline(string_of_int(res));
```

# Ruby
```rb
A,T=gets.chomp.split(" ").map(&:to_i);
print("#{(A-1)/T}\n")
```

# Rust
```rust
use proconio::input;
fn main(){
    input!{
        A: i32,
        T: i32
    }
    println!("{}",(A-1)/T);
}
```

# SageMath
```
A,T = map(int, input().split())
print((A-1)//T)
```

# Scala
```scala
import scala.io.StdIn.*
object Main extends App {
    var tmp = readLine.split(" ")
    var A = tmp(0).toInt
    var T = tmp(1).toInt
    println((A-1)/T);
}
```

# Scheme
```scheme
(define (main args)
  (let* ([a (read)]
         [t (read)])
    (print (quotient (- a 1) t)))
  0)
```

# Sed
```sed
s/^\(.*\) \(.*\)$/echo $(((\1-1)\/\2))/e
```

# Seed7
```
$ include "seed7_05.s7i";

const proc: main is func
  local
    var integer: A is 0;
    var integer: T is 0;
  begin
    read(A);
    read(T);
    writeln((A - 1) div T);
  end func;
```

# Swift
```swift
let tmp = readLine()!.split(separator: " ").map { Int($0)! }
let A = tmp[0]
let T = tmp[1]
print("\((A - 1)/T)")
```

# Text
```
```

# TypeScript
```typescript
import * as fs from 'fs';
let tmp = fs.readFileSync('/dev/stdin', 'utf8').split(' ');
let A = BigInt(tmp[0]);
let T = BigInt(tmp[1]);
console.log(((A - 1n) / T).toString());
```

# Unison
```
get_int : '{IO, Exception} Int
get_int = do
  line = !readLine
  Optional.getOrBug "Invalid Input" (Int.fromText line)

get_ints : '{IO, Exception} List(Int)
get_ints = do
  line = !readLine
  w = words line
  v = List.map Int.fromText w
  List.map (Optional.getOrBug "Invalid Input") v

main : '{IO, Exception} ()
main = do
  tmp = get_ints()
  a = List.unsafeAt 0 tmp
  t = List.unsafeAt 1 tmp
  printLine (Int.toText ((a Int.- +1) Int./ t)
```

# V
```
import os

fn main() {
  tmp := os.get_line().split(' ').map(it.int())
  a := tmp[0]
  t := tmp[1]
  println("${(a - 1) / t}")
}
```

# Vim
```vim
dw:let a = @"
dw:let t = @"
:put! = (a - 1) / t
ZZ
```

# Visual Basic
```vb
module A
  sub Main(ByVal args() as String)
    Dim line(10) as String
    Dim A as Integer
    Dim T as Integer
    line=Console.ReadLine().Split()
    A = int(line(0))
    T = int(line(1))
    Console.WriteLine((A-1)\T)
  end sub
end module
```

# Whitespace
おそらくコピペしてもACがとれないので、提出リンクを貼っておきます。

[https://atcoder.jp/contests/oupc2023-day1/submissions/49183555](https://atcoder.jp/contests/oupc2023-day1/submissions/49183555)

```
 	 					 	   

 	 					 	   
 
	   	
	  	 
		 	 	
 	   	 	 
	
  



   					 	   
   

   						  	 
   
	
	    
			 
    	     
	  	
	  								  
 
    	 	 
	  	
	  								  
 
	   	 	 
	  
   		    
	  		   
 
 						  	 

   								  
 


	



```

# Zig
```zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const stdin = std.io.getStdIn().reader();

var buff: [100]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(&buff);
const alloc = fba.allocator();

pub fn main() !void {
  const line = if (try stdin.readUntilDelimiterOrEofAlloc(alloc, '\n', 100)) |str| str else "0 0";
  const index = std.mem.indexOfScalar(u8, line, ' ').?;
  const a = try std.fmt.parseInt(i32, line[0..index], 10);
  const t = try std.fmt.parseInt(i32, line[index + 1..], 10);
  try stdout.print("{}", .{@divTrunc(a-1,t)});
}
```

# Zsh
```zsh
read A T
echo $(((A-1)/T))
```

# bc
```
scale=0
(read()-1)/read()
```

# dc
```
?r1-r/p
```

# jq
```
split(" ")|map(tonumber)as$tmp|($tmp[0]-1)/$tmp[1]|floor
```

# なでしこ
```
tmp=「」と尋ねて「 」で区切る。
Aは「{tmp[0]}n」をJS実行。
Tは「{tmp[1]}n」をJS実行。
(A-1n)/Tを表示。
```

# プロデル
```
【tmp：整数の配列】は、コンソールから受け取ったものを「 」で区切ったもの。
【A：整数】は、tmp(1)。
【T：整数】は、tmp(2)。
(A-1)\Tを表示。
```

# あとがき
並べてみると、ほとんどの言語では小数除算に`/`が採用されている反面、整数除算は各言語の工夫が見られますね。

追記
[littlegirl112](https://twitter.com/littlegirl0820)さんにいくつかコードをいただきました。ありがとうございます。
[KowerKoint](https://twitter.com/KowerKoint2010)さんにいくつかコードをいただきました。ありがとうございます。